{
"cells": [
{
"cell_type": "code",
"execution_count": 176,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.558466Z",
"start_time": "2019-04-29T13:16:53.554327Z"
}
},
"outputs": [],
"source": [
"# Common imports\n",
"import numpy as np\n",
"import os\n",
"\n",
"from math import log\n",
"import pandas as pd\n",
"import operator\n",
"import numpy as np\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 载入数据并查看"
]
},
{
"cell_type": "code",
"execution_count": 177,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.579311Z",
"start_time": "2019-04-29T13:16:53.560121Z"
},
"scrolled": true
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" department | \n",
" status | \n",
" age | \n",
" salary | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" Sales | \n",
" Senior | \n",
" 3135 | \n",
" 46K50K | \n",
"
\n",
" \n",
" | 1 | \n",
" Sales | \n",
" Junior | \n",
" 2630 | \n",
" 26K30K | \n",
"
\n",
" \n",
" | 2 | \n",
" Sales | \n",
" Junior | \n",
" 3135 | \n",
" 31K35K | \n",
"
\n",
" \n",
" | 3 | \n",
" Systems | \n",
" Junior | \n",
" 2125 | \n",
" 46K50K | \n",
"
\n",
" \n",
" | 4 | \n",
" Systems | \n",
" Senior | \n",
" 3135 | \n",
" 66K70K | \n",
"
\n",
" \n",
" | 5 | \n",
" Systems | \n",
" Junior | \n",
" 2630 | \n",
" 46K50K | \n",
"
\n",
" \n",
" | 6 | \n",
" Systems | \n",
" Senior | \n",
" 4145 | \n",
" 66K70K | \n",
"
\n",
" \n",
" | 7 | \n",
" Marketing | \n",
" Senior | \n",
" 3640 | \n",
" 46K50K | \n",
"
\n",
" \n",
" | 8 | \n",
" Marketing | \n",
" Junior | \n",
" 3135 | \n",
" 41K45K | \n",
"
\n",
" \n",
" | 9 | \n",
" Secretary | \n",
" Senior | \n",
" 4650 | \n",
" 36K40K | \n",
"
\n",
" \n",
" | 10 | \n",
" Secretary | \n",
" Junior | \n",
" 2630 | \n",
" 26K30K | \n",
"
\n",
" \n",
"
\n",
"
` tag. Default ``pd.options.html.border``.\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | buf : StringIO-like, optional\n",
" | buffer to write to\n",
" | columns : sequence, optional\n",
" | the subset of columns to write; default None writes all columns\n",
" | col_space : int, optional\n",
" | the minimum width of each column\n",
" | header : bool, optional\n",
" | whether to print column labels, default True\n",
" | index : bool, optional\n",
" | whether to print index (row) labels, default True\n",
" | na_rep : string, optional\n",
" | string representation of NAN to use, default 'NaN'\n",
" | formatters : list or dict of one-parameter functions, optional\n",
" | formatter functions to apply to columns' elements by position or name,\n",
" | default None. 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, optional\n",
" | formatter function to apply to columns' elements if they are floats,\n",
" | default None. The result of this function must be a unicode string.\n",
" | sparsify : bool, optional\n",
" | Set to False for a DataFrame with a hierarchical index to print every\n",
" | multiindex key at each row, default True\n",
" | index_names : bool, optional\n",
" | Prints the names of the indexes, default True\n",
" | line_width : int, optional\n",
" | Width to wrap a line in characters, default no wrap\n",
" | justify : {'left', 'right', 'center', 'justify',\n",
" | 'justify-all', 'start', 'end', 'inherit',\n",
" | 'match-parent', 'initial', 'unset'}, default None\n",
" | How to justify the column labels. If None uses the option from\n",
" | the print configuration (controlled by set_option), 'right' out\n",
" | of the box.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | formatted : string (or unicode, depending on data and options)\n",
" | \n",
" | to_panel(self)\n",
" | Transform long (stacked) format (DataFrame) into wide (3D, Panel)\n",
" | format.\n",
" | \n",
" | Currently the index of the DataFrame must be a 2-level MultiIndex. This\n",
" | may be generalized later\n",
" | \n",
" | Returns\n",
" | -------\n",
" | panel : Panel\n",
" | \n",
" | to_parquet(self, fname, engine='auto', compression='snappy', **kwargs)\n",
" | Write a DataFrame to the binary parquet format.\n",
" | \n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | fname : str\n",
" | string file path\n",
" | engine : {'auto', 'pyarrow', 'fastparquet'}, default 'auto'\n",
" | Parquet reader library to use. If 'auto', then the option\n",
" | 'io.parquet.engine' is used. If 'auto', then the first\n",
" | library to be installed is used.\n",
" | compression : str, optional, default 'snappy'\n",
" | compression method, includes {'gzip', 'snappy', 'brotli'}\n",
" | kwargs\n",
" | Additional keyword arguments passed to the engine\n",
" | \n",
" | to_period(self, freq=None, axis=0, copy=True)\n",
" | Convert DataFrame from DatetimeIndex to PeriodIndex with desired\n",
" | frequency (inferred from index if not passed)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : string, default\n",
" | axis : {0 or 'index', 1 or 'columns'}, default 0\n",
" | The axis to convert (the index by default)\n",
" | copy : boolean, default True\n",
" | If False then underlying input data is not copied\n",
" | \n",
" | Returns\n",
" | -------\n",
" | ts : TimeSeries with PeriodIndex\n",
" | \n",
" | to_records(self, index=True, convert_datetime64=True)\n",
" | Convert DataFrame to record array. Index will be put in the\n",
" | 'index' field of the record array if requested\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | index : boolean, default True\n",
" | Include index in resulting record array, stored in 'index' field\n",
" | convert_datetime64 : boolean, default True\n",
" | Whether to convert the index to datetime.datetime if it is a\n",
" | DatetimeIndex\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : recarray\n",
" | \n",
" | to_sparse(self, fill_value=None, kind='block')\n",
" | Convert to SparseDataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | fill_value : float, default NaN\n",
" | kind : {'block', 'integer'}\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : SparseDataFrame\n",
" | \n",
" | to_stata(self, fname, convert_dates=None, write_index=True, encoding='latin-1', byteorder=None, time_stamp=None, data_label=None, variable_labels=None)\n",
" | A class for writing Stata binary dta files from array-like objects\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | fname : str or buffer\n",
" | String path of file-like object\n",
" | convert_dates : dict\n",
" | Dictionary mapping columns containing datetime types to stata\n",
" | internal format to use when wirting the dates. Options are 'tc',\n",
" | 'td', 'tm', 'tw', 'th', 'tq', 'ty'. Column can be either an integer\n",
" | or a name. Datetime columns that do not have a conversion type\n",
" | specified will be converted to 'tc'. Raises NotImplementedError if\n",
" | a datetime column has timezone information\n",
" | write_index : bool\n",
" | Write the index to Stata dataset.\n",
" | encoding : str\n",
" | Default is latin-1. Unicode is not supported\n",
" | byteorder : str\n",
" | Can be \">\", \"<\", \"little\", or \"big\". default is `sys.byteorder`\n",
" | time_stamp : datetime\n",
" | A datetime to use as file creation date. Default is the current\n",
" | time.\n",
" | dataset_label : str\n",
" | A label for the data set. Must be 80 characters or smaller.\n",
" | variable_labels : dict\n",
" | Dictionary containing columns as keys and variable labels as\n",
" | values. Each label must be 80 characters or smaller.\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | Raises\n",
" | ------\n",
" | NotImplementedError\n",
" | * If datetimes contain timezone information\n",
" | * Column dtype is not representable in Stata\n",
" | ValueError\n",
" | * Columns listed in convert_dates are noth either datetime64[ns]\n",
" | or datetime.datetime\n",
" | * Column listed in convert_dates is not in DataFrame\n",
" | * Categorical label contains more than 32,000 characters\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> writer = StataWriter('./data_file.dta', data)\n",
" | >>> writer.write_file()\n",
" | \n",
" | Or with dates\n",
" | \n",
" | >>> writer = StataWriter('./date_data_file.dta', data, {2 : 'tw'})\n",
" | >>> writer.write_file()\n",
" | \n",
" | to_string(self, buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, line_width=None, max_rows=None, max_cols=None, show_dimensions=False)\n",
" | Render a DataFrame to a console-friendly tabular output.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | buf : StringIO-like, optional\n",
" | buffer to write to\n",
" | columns : sequence, optional\n",
" | the subset of columns to write; default None writes all columns\n",
" | col_space : int, optional\n",
" | the minimum width of each column\n",
" | header : bool, optional\n",
" | Write out the column names. If a list of strings is given, it is assumed to be aliases for the column names\n",
" | index : bool, optional\n",
" | whether to print index (row) labels, default True\n",
" | na_rep : string, optional\n",
" | string representation of NAN to use, default 'NaN'\n",
" | formatters : list or dict of one-parameter functions, optional\n",
" | formatter functions to apply to columns' elements by position or name,\n",
" | default None. 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, optional\n",
" | formatter function to apply to columns' elements if they are floats,\n",
" | default None. The result of this function must be a unicode string.\n",
" | sparsify : bool, optional\n",
" | Set to False for a DataFrame with a hierarchical index to print every\n",
" | multiindex key at each row, default True\n",
" | index_names : bool, optional\n",
" | Prints the names of the indexes, default True\n",
" | line_width : int, optional\n",
" | Width to wrap a line in characters, default no wrap\n",
" | justify : {'left', 'right', 'center', 'justify',\n",
" | 'justify-all', 'start', 'end', 'inherit',\n",
" | 'match-parent', 'initial', 'unset'}, default None\n",
" | How to justify the column labels. If None uses the option from\n",
" | the print configuration (controlled by set_option), 'right' out\n",
" | of the box.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | formatted : string (or unicode, depending on data and options)\n",
" | \n",
" | to_timestamp(self, freq=None, how='start', axis=0, copy=True)\n",
" | Cast to DatetimeIndex of timestamps, at *beginning* of period\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : string, 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",
" | axis : {0 or 'index', 1 or 'columns'}, default 0\n",
" | The axis to convert (the index by default)\n",
" | copy : boolean, default True\n",
" | If false then underlying input data is not copied\n",
" | \n",
" | Returns\n",
" | -------\n",
" | df : DataFrame with DatetimeIndex\n",
" | \n",
" | transform(self, func, *args, **kwargs)\n",
" | Call function producing a like-indexed NDFrame\n",
" | and return a NDFrame with the transformed values\n",
" | \n",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | func : callable, string, dictionary, or list of string/callables\n",
" | To apply to column\n",
" | \n",
" | Accepted Combinations are:\n",
" | \n",
" | - string function name\n",
" | - function\n",
" | - list of functions\n",
" | - dict of column names -> functions (or list of functions)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | transformed : NDFrame\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'],\n",
" | ... index=pd.date_range('1/1/2000', periods=10))\n",
" | df.iloc[3:7] = np.nan\n",
" | \n",
" | >>> df.transform(lambda x: (x - x.mean()) / x.std())\n",
" | A B C\n",
" | 2000-01-01 0.579457 1.236184 0.123424\n",
" | 2000-01-02 0.370357 -0.605875 -1.231325\n",
" | 2000-01-03 1.455756 -0.277446 0.288967\n",
" | 2000-01-04 NaN NaN NaN\n",
" | 2000-01-05 NaN NaN NaN\n",
" | 2000-01-06 NaN NaN NaN\n",
" | 2000-01-07 NaN NaN NaN\n",
" | 2000-01-08 -0.498658 1.274522 1.642524\n",
" | 2000-01-09 -0.540524 -1.012676 -0.828968\n",
" | 2000-01-10 -1.366388 -0.614710 0.005378\n",
" | \n",
" | See also\n",
" | --------\n",
" | pandas.NDFrame.aggregate\n",
" | pandas.NDFrame.apply\n",
" | \n",
" | transpose(self, *args, **kwargs)\n",
" | Transpose index and columns\n",
" | \n",
" | truediv(self, other, axis='columns', level=None, fill_value=None)\n",
" | Floating division of dataframe and other, element-wise (binary operator `truediv`).\n",
" | \n",
" | Equivalent to ``dataframe / other``, but with support to substitute a fill_value for\n",
" | missing data in one of the inputs.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Series, DataFrame, or constant\n",
" | axis : {0, 1, 'index', 'columns'}\n",
" | For Series input, axis to match Series index on\n",
" | fill_value : None or float value, default None\n",
" | Fill missing (NaN) values with this value. If both DataFrame\n",
" | locations are missing, the result will be missing\n",
" | level : int or name\n",
" | Broadcast across a level, matching Index values on the\n",
" | passed MultiIndex level\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Mismatched indices will be unioned together\n",
" | \n",
" | Returns\n",
" | -------\n",
" | result : DataFrame\n",
" | \n",
" | See also\n",
" | --------\n",
" | DataFrame.rtruediv\n",
" | \n",
" | unstack(self, level=-1, fill_value=None)\n",
" | Pivot a level of the (necessarily hierarchical) index labels, returning\n",
" | a DataFrame having a new level of column labels whose inner-most level\n",
" | consists of the pivoted index labels. If the index is not a MultiIndex,\n",
" | the output will be a Series (the analogue of stack when the columns are\n",
" | not a MultiIndex).\n",
" | The level involved will automatically get sorted.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | level : int, string, or list of these, default -1 (last level)\n",
" | Level(s) of index to unstack, can pass level name\n",
" | fill_value : replace NaN with this value if the unstack produces\n",
" | missing values\n",
" | \n",
" | .. versionadded: 0.18.0\n",
" | \n",
" | See also\n",
" | --------\n",
" | DataFrame.pivot : Pivot a table based on column values.\n",
" | DataFrame.stack : Pivot a level of the column labels (inverse operation\n",
" | from `unstack`).\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),\n",
" | ... ('two', 'a'), ('two', 'b')])\n",
" | >>> s = pd.Series(np.arange(1.0, 5.0), index=index)\n",
" | >>> s\n",
" | one a 1.0\n",
" | b 2.0\n",
" | two a 3.0\n",
" | b 4.0\n",
" | dtype: float64\n",
" | \n",
" | >>> s.unstack(level=-1)\n",
" | a b\n",
" | one 1.0 2.0\n",
" | two 3.0 4.0\n",
" | \n",
" | >>> s.unstack(level=0)\n",
" | one two\n",
" | a 1.0 3.0\n",
" | b 2.0 4.0\n",
" | \n",
" | >>> df = s.unstack(level=0)\n",
" | >>> df.unstack()\n",
" | one a 1.0\n",
" | b 2.0\n",
" | two a 3.0\n",
" | b 4.0\n",
" | dtype: float64\n",
" | \n",
" | Returns\n",
" | -------\n",
" | unstacked : DataFrame or Series\n",
" | \n",
" | update(self, other, join='left', overwrite=True, filter_func=None, raise_conflict=False)\n",
" | Modify DataFrame in place using non-NA values from passed\n",
" | DataFrame. Aligns on indices\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : DataFrame, or object coercible into a DataFrame\n",
" | join : {'left'}, default 'left'\n",
" | overwrite : boolean, default True\n",
" | If True then overwrite values for common keys in the calling frame\n",
" | filter_func : callable(1d-array) -> 1d-array, default None\n",
" | Can choose to replace values other than NA. Return True for values\n",
" | that should be updated\n",
" | raise_conflict : boolean\n",
" | If True, will raise an error if the DataFrame and other both\n",
" | contain data in the same place.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df = pd.DataFrame({'A': [1, 2, 3],\n",
" | ... 'B': [400, 500, 600]})\n",
" | >>> new_df = pd.DataFrame({'B': [4, 5, 6],\n",
" | ... 'C': [7, 8, 9]})\n",
" | >>> df.update(new_df)\n",
" | >>> df\n",
" | A B\n",
" | 0 1 4\n",
" | 1 2 5\n",
" | 2 3 6\n",
" | \n",
" | >>> df = pd.DataFrame({'A': ['a', 'b', 'c'],\n",
" | ... 'B': ['x', 'y', 'z']})\n",
" | >>> new_df = pd.DataFrame({'B': ['d', 'e', 'f', 'g', 'h', 'i']})\n",
" | >>> df.update(new_df)\n",
" | >>> df\n",
" | A B\n",
" | 0 a d\n",
" | 1 b e\n",
" | 2 c f\n",
" | \n",
" | >>> df = pd.DataFrame({'A': ['a', 'b', 'c'],\n",
" | ... 'B': ['x', 'y', 'z']})\n",
" | >>> new_column = pd.Series(['d', 'e'], name='B', index=[0, 2])\n",
" | >>> df.update(new_column)\n",
" | >>> df\n",
" | A B\n",
" | 0 a d\n",
" | 1 b y\n",
" | 2 c e\n",
" | >>> df = pd.DataFrame({'A': ['a', 'b', 'c'],\n",
" | ... 'B': ['x', 'y', 'z']})\n",
" | >>> new_df = pd.DataFrame({'B': ['d', 'e']}, index=[1, 2])\n",
" | >>> df.update(new_df)\n",
" | >>> df\n",
" | A B\n",
" | 0 a x\n",
" | 1 b d\n",
" | 2 c e\n",
" | \n",
" | If ``other`` contains NaNs the corresponding values are not updated\n",
" | in the original dataframe.\n",
" | \n",
" | >>> df = pd.DataFrame({'A': [1, 2, 3],\n",
" | ... 'B': [400, 500, 600]})\n",
" | >>> new_df = pd.DataFrame({'B': [4, np.nan, 6]})\n",
" | >>> df.update(new_df)\n",
" | >>> df\n",
" | A B\n",
" | 0 1 4.0\n",
" | 1 2 500.0\n",
" | 2 3 6.0\n",
" | \n",
" | var(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None, **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), columns (1)}\n",
" | skipna : boolean, default True\n",
" | Exclude NA/null values. If an entire row/column is NA, the result\n",
" | will be NA\n",
" | level : int or level name, default None\n",
" | If the axis is a MultiIndex (hierarchical), count along a\n",
" | particular level, collapsing into a Series\n",
" | ddof : int, default 1\n",
" | degrees of freedom\n",
" | numeric_only : boolean, default None\n",
" | Include only float, int, boolean columns. If None, will attempt to use\n",
" | everything, then use only numeric data. Not implemented for Series.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | var : Series or DataFrame (if level specified)\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Class methods defined here:\n",
" | \n",
" | from_csv(path, header=0, sep=',', index_col=0, parse_dates=True, encoding=None, tupleize_cols=None, infer_datetime_format=False) from builtins.type\n",
" | Read CSV file (DEPRECATED, please use :func:`pandas.read_csv`\n",
" | instead).\n",
" | \n",
" | It is preferable to use the more powerful :func:`pandas.read_csv`\n",
" | for most general purposes, but ``from_csv`` makes for an easy\n",
" | roundtrip to and from a file (the exact counterpart of\n",
" | ``to_csv``), especially with a DataFrame of time series data.\n",
" | \n",
" | This method only differs from the preferred :func:`pandas.read_csv`\n",
" | in some defaults:\n",
" | \n",
" | - `index_col` is ``0`` instead of ``None`` (take first column as index\n",
" | by default)\n",
" | - `parse_dates` is ``True`` instead of ``False`` (try parsing the index\n",
" | as datetime by default)\n",
" | \n",
" | So a ``pd.DataFrame.from_csv(path)`` can be replaced by\n",
" | ``pd.read_csv(path, index_col=0, parse_dates=True)``.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path : string file path or file handle / StringIO\n",
" | header : int, default 0\n",
" | Row to use as header (skip prior rows)\n",
" | sep : string, default ','\n",
" | Field delimiter\n",
" | index_col : int or sequence, default 0\n",
" | Column to use for index. If a sequence is given, a MultiIndex\n",
" | is used. Different default from read_table\n",
" | parse_dates : boolean, default True\n",
" | Parse dates. Different default from read_table\n",
" | tupleize_cols : boolean, default False\n",
" | write multi_index columns as a list of tuples (if True)\n",
" | or new (expanded format) if False)\n",
" | infer_datetime_format: boolean, default False\n",
" | If True and `parse_dates` is True for a column, try to infer the\n",
" | datetime format based on the first datetime string. If the format\n",
" | can be inferred, there often will be a large parsing speed-up.\n",
" | \n",
" | See also\n",
" | --------\n",
" | pandas.read_csv\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : DataFrame\n",
" | \n",
" | from_dict(data, orient='columns', dtype=None) from builtins.type\n",
" | Construct DataFrame from dict of array-like or dicts\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : dict\n",
" | {field : array-like} or {field : dict}\n",
" | orient : {'columns', 'index'}, default 'columns'\n",
" | The \"orientation\" of the data. If the keys of the passed dict\n",
" | should be the columns of the resulting DataFrame, pass 'columns'\n",
" | (default). Otherwise if the keys should be rows, pass 'index'.\n",
" | dtype : dtype, default None\n",
" | Data type to force, otherwise infer\n",
" | \n",
" | Returns\n",
" | -------\n",
" | DataFrame\n",
" | \n",
" | from_items(items, columns=None, orient='columns') from builtins.type\n",
" | Convert (key, value) pairs to DataFrame. The keys will be the axis\n",
" | index (usually the columns, but depends on the specified\n",
" | orientation). The values should be arrays or Series.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | items : sequence of (key, value) pairs\n",
" | Values should be arrays or Series.\n",
" | columns : sequence of column labels, optional\n",
" | Must be passed if orient='index'.\n",
" | orient : {'columns', 'index'}, default 'columns'\n",
" | The \"orientation\" of the data. If the keys of the\n",
" | input correspond to column labels, pass 'columns'\n",
" | (default). Otherwise if the keys correspond to the index,\n",
" | pass 'index'.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | frame : DataFrame\n",
" | \n",
" | from_records(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None) from builtins.type\n",
" | Convert structured or record ndarray to DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | data : ndarray (structured dtype), list of tuples, dict, or DataFrame\n",
" | index : string, list of fields, array-like\n",
" | Field of array to use as the index, alternately a specific set of\n",
" | input labels to use\n",
" | exclude : sequence, default None\n",
" | Columns or fields to exclude\n",
" | columns : sequence, default None\n",
" | Column names to use. If the passed data do not have names\n",
" | associated with them, this argument provides names for the\n",
" | columns. Otherwise this argument indicates the order of the columns\n",
" | in the result (any names not found in the data will become all-NA\n",
" | columns)\n",
" | coerce_float : boolean, default False\n",
" | Attempt to convert values of non-string, non-numeric objects (like\n",
" | decimal.Decimal) to floating point, useful for SQL result sets\n",
" | \n",
" | Returns\n",
" | -------\n",
" | df : DataFrame\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors defined here:\n",
" | \n",
" | T\n",
" | Transpose index and columns\n",
" | \n",
" | axes\n",
" | Return a list with the row axis labels and column axis labels as the\n",
" | only members. They are returned in that order.\n",
" | \n",
" | columns\n",
" | \n",
" | index\n",
" | \n",
" | shape\n",
" | Return a tuple representing the dimensionality of the DataFrame.\n",
" | \n",
" | style\n",
" | Property returning a Styler object containing methods for\n",
" | building a styled HTML representation fo the DataFrame.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.io.formats.style.Styler\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data and other attributes defined here:\n",
" | \n",
" | plot = \n",
" | DataFrame plotting accessor and method\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df.plot.line()\n",
" | >>> df.plot.scatter('x', 'y')\n",
" | >>> df.plot.hexbin()\n",
" | \n",
" | These plotting methods can also be accessed by calling the accessor as a\n",
" | method with the ``kind`` argument:\n",
" | ``df.plot(kind='line')`` is equivalent to ``df.plot.line()``\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.generic.NDFrame:\n",
" | \n",
" | __abs__(self)\n",
" | \n",
" | __array__(self, dtype=None)\n",
" | \n",
" | __array_wrap__(self, result, context=None)\n",
" | \n",
" | __bool__ = __nonzero__(self)\n",
" | \n",
" | __contains__(self, key)\n",
" | True if the key is in the info axis\n",
" | \n",
" | __copy__(self, deep=True)\n",
" | \n",
" | __deepcopy__(self, memo=None)\n",
" | \n",
" | __delitem__(self, key)\n",
" | Delete item\n",
" | \n",
" | __finalize__(self, other, method=None, **kwargs)\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 : optional, a passed method name ; possibly to take different\n",
" | types of propagation actions based on this\n",
" | \n",
" | __getattr__(self, name)\n",
" | After regular attribute access, try looking up the name\n",
" | This allows simpler access to columns for interactive use.\n",
" | \n",
" | __getstate__(self)\n",
" | \n",
" | __hash__(self)\n",
" | Return hash(self).\n",
" | \n",
" | __invert__(self)\n",
" | \n",
" | __iter__(self)\n",
" | Iterate over infor axis\n",
" | \n",
" | __neg__(self)\n",
" | \n",
" | __nonzero__(self)\n",
" | \n",
" | __round__(self, decimals=0)\n",
" | \n",
" | __setattr__(self, name, value)\n",
" | After regular attribute access, try setting the name\n",
" | This allows simpler access to columns for interactive use.\n",
" | \n",
" | __setstate__(self, state)\n",
" | \n",
" | abs(self)\n",
" | Return an object with absolute value taken--only applicable to objects\n",
" | that are all numeric.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | abs: type of caller\n",
" | \n",
" | add_prefix(self, prefix)\n",
" | Concatenate prefix string with panel items names.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | prefix : string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | with_prefix : type of caller\n",
" | \n",
" | add_suffix(self, suffix)\n",
" | Concatenate suffix string with panel items names.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | suffix : string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | with_suffix : type of caller\n",
" | \n",
" | as_blocks(self, copy=True)\n",
" | Convert the frame to a dict of dtype -> Constructor Types that each has\n",
" | a homogeneous dtype.\n",
" | \n",
" | .. deprecated:: 0.21.0\n",
" | \n",
" | NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in\n",
" | as_matrix)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | copy : boolean, default True\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : a dict of dtype -> Constructor Types\n",
" | \n",
" | as_matrix(self, columns=None)\n",
" | Convert the frame to its Numpy-array representation.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | columns: list, optional, default:None\n",
" | If None, return all columns, otherwise, returns specified columns.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values : ndarray\n",
" | If the caller is heterogeneous and contains booleans or objects,\n",
" | the result will be of dtype=object. See Notes.\n",
" | \n",
" | \n",
" | Notes\n",
" | -----\n",
" | Return is NOT a Numpy-matrix, rather, a Numpy-array.\n",
" | \n",
" | The dtype will be a lower-common-denominator dtype (implicit\n",
" | upcasting); that is to say if the dtypes (even of numeric types)\n",
" | are mixed, the one that accommodates all will be chosen. Use this\n",
" | with care if you are not dealing with the blocks.\n",
" | \n",
" | e.g. If the dtypes are float16 and float32, dtype will be upcast to\n",
" | float32. If dtypes are int32 and uint8, dtype will be upcase to\n",
" | int32. By numpy.find_common_type convention, mixing int64 and uint64\n",
" | will result in a flot64 dtype.\n",
" | \n",
" | This method is provided for backwards compatibility. Generally,\n",
" | it is recommended to use '.values'.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.DataFrame.values\n",
" | \n",
" | asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None)\n",
" | Convert TimeSeries to specified frequency.\n",
" | \n",
" | Optionally provide filling method to pad/backfill missing values.\n",
" | \n",
" | Returns the original data conformed to a new index with the specified\n",
" | frequency. ``resample`` is more appropriate if an operation, such as\n",
" | summarization, is necessary to represent the data at the new frequency.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | freq : DateOffset object, 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",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | converted : type of caller\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | Start by creating a series with 4 one minute timestamps.\n",
" | \n",
" | >>> index = pd.date_range('1/1/2000', periods=4, freq='T')\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",
" | See Also\n",
" | --------\n",
" | reindex\n",
" | \n",
" | Notes\n",
" | -----\n",
" | To learn more about the frequency strings, please see `this link\n",
" | `__.\n",
" | \n",
" | asof(self, where, subset=None)\n",
" | The last row without any NaN is taken (or the last row without\n",
" | NaN considering only the subset of columns in the case of a DataFrame)\n",
" | \n",
" | .. versionadded:: 0.19.0 For DataFrame\n",
" | \n",
" | If there is no good value, NaN is returned for a Series\n",
" | a Series of NaN values for a DataFrame\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | where : date or array of dates\n",
" | subset : string or list of strings, default None\n",
" | if not None use these columns for NaN propagation\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Dates are assumed to be sorted\n",
" | Raises if this is not the case\n",
" | \n",
" | Returns\n",
" | -------\n",
" | where is scalar\n",
" | \n",
" | - value or NaN if input is Series\n",
" | - Series if input is DataFrame\n",
" | \n",
" | where is Index: same shape object as input\n",
" | \n",
" | See Also\n",
" | --------\n",
" | merge_asof\n",
" | \n",
" | astype(self, dtype, copy=True, errors='raise', **kwargs)\n",
" | Cast a pandas object to a specified dtype ``dtype``.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | dtype : data type, or dict of column name -> data type\n",
" | Use a numpy.dtype or Python type to cast entire pandas object to\n",
" | the same type. Alternatively, use {col: dtype, ...}, where col is a\n",
" | column label and dtype is a numpy.dtype or Python type to cast one\n",
" | or more of the DataFrame's 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",
" | 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",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | raise_on_error : raise on invalid input\n",
" | .. deprecated:: 0.20.0\n",
" | Use ``errors`` instead\n",
" | kwargs : keyword arguments to pass on to the constructor\n",
" | \n",
" | Returns\n",
" | -------\n",
" | casted : type of caller\n",
" | \n",
" | Examples\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, int64): [1, 2]\n",
" | \n",
" | Convert to ordered categorical type with custom ordering:\n",
" | \n",
" | >>> ser.astype('category', ordered=True, categories=[2, 1])\n",
" | 0 1\n",
" | 1 2\n",
" | dtype: category\n",
" | Categories (2, int64): [2 < 1]\n",
" | \n",
" | Note that using ``copy=False`` and changing data on a new\n",
" | pandas object may propagate changes:\n",
" | \n",
" | >>> s1 = pd.Series([1,2])\n",
" | >>> s2 = s1.astype('int', copy=False)\n",
" | >>> s2[0] = 10\n",
" | >>> s1 # note that s1[0] has changed too\n",
" | 0 10\n",
" | 1 2\n",
" | dtype: int64\n",
" | \n",
" | See also\n",
" | --------\n",
" | pandas.to_datetime : Convert argument to datetime.\n",
" | pandas.to_timedelta : Convert argument to timedelta.\n",
" | pandas.to_numeric : Convert argument to a numeric type.\n",
" | numpy.ndarray.astype : Cast a numpy array to a specified type.\n",
" | \n",
" | at_time(self, time, asof=False)\n",
" | Select values at particular time of day (e.g. 9:30AM).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | time : datetime.time or string\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values_at_time : type of caller\n",
" | \n",
" | between_time(self, start_time, end_time, include_start=True, include_end=True)\n",
" | Select values between particular times of the day (e.g., 9:00-9:30 AM).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | start_time : datetime.time or string\n",
" | end_time : datetime.time or string\n",
" | include_start : boolean, default True\n",
" | include_end : boolean, default True\n",
" | \n",
" | Returns\n",
" | -------\n",
" | values_between_time : type of caller\n",
" | \n",
" | bfill(self, axis=None, inplace=False, limit=None, downcast=None)\n",
" | Synonym for :meth:`DataFrame.fillna(method='bfill') `\n",
" | \n",
" | bool(self)\n",
" | Return the bool of a single element PandasObject.\n",
" | \n",
" | This must be a boolean scalar value, either True or False. Raise a\n",
" | ValueError if the PandasObject does not have exactly 1 element, or that\n",
" | element is not boolean\n",
" | \n",
" | clip(self, lower=None, upper=None, axis=None, inplace=False, *args, **kwargs)\n",
" | Trim values at input threshold(s).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | lower : float or array_like, default None\n",
" | upper : float or array_like, default None\n",
" | axis : int or string axis name, optional\n",
" | Align object with lower and upper along the given axis.\n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : Series\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df\n",
" | 0 1\n",
" | 0 0.335232 -1.256177\n",
" | 1 -1.367855 0.746646\n",
" | 2 0.027753 -1.176076\n",
" | 3 0.230930 -0.679613\n",
" | 4 1.261967 0.570967\n",
" | \n",
" | >>> df.clip(-1.0, 0.5)\n",
" | 0 1\n",
" | 0 0.335232 -1.000000\n",
" | 1 -1.000000 0.500000\n",
" | 2 0.027753 -1.000000\n",
" | 3 0.230930 -0.679613\n",
" | 4 0.500000 0.500000\n",
" | \n",
" | >>> t\n",
" | 0 -0.3\n",
" | 1 -0.2\n",
" | 2 -0.1\n",
" | 3 0.0\n",
" | 4 0.1\n",
" | dtype: float64\n",
" | \n",
" | >>> df.clip(t, t + 1, axis=0)\n",
" | 0 1\n",
" | 0 0.335232 -0.300000\n",
" | 1 -0.200000 0.746646\n",
" | 2 0.027753 -0.100000\n",
" | 3 0.230930 0.000000\n",
" | 4 1.100000 0.570967\n",
" | \n",
" | clip_lower(self, threshold, axis=None, inplace=False)\n",
" | Return copy of the input with values below given value(s) truncated.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | threshold : float or array_like\n",
" | axis : int or string axis name, optional\n",
" | Align object with threshold along the given axis.\n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | See Also\n",
" | --------\n",
" | clip\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : same type as input\n",
" | \n",
" | clip_upper(self, threshold, axis=None, inplace=False)\n",
" | Return copy of input with values above given value(s) truncated.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | threshold : float or array_like\n",
" | axis : int or string axis name, optional\n",
" | Align object with threshold along the given axis.\n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | See Also\n",
" | --------\n",
" | clip\n",
" | \n",
" | Returns\n",
" | -------\n",
" | clipped : same type as input\n",
" | \n",
" | consolidate(self, inplace=False)\n",
" | DEPRECATED: consolidate will be an internal implementation only.\n",
" | \n",
" | convert_objects(self, convert_dates=True, convert_numeric=False, convert_timedeltas=True, copy=True)\n",
" | Deprecated.\n",
" | Attempt to infer better dtype for object columns\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | convert_dates : boolean, default True\n",
" | If True, convert to date where possible. If 'coerce', force\n",
" | conversion, with unconvertible values becoming NaT.\n",
" | convert_numeric : boolean, default False\n",
" | If True, attempt to coerce to numbers (including strings), with\n",
" | unconvertible values becoming NaN.\n",
" | convert_timedeltas : boolean, default True\n",
" | If True, convert to timedelta where possible. If 'coerce', force\n",
" | conversion, with unconvertible values becoming NaT.\n",
" | copy : boolean, default True\n",
" | If True, return a copy even if no copy is necessary (e.g. no\n",
" | conversion was done). Note: This is meant for internal use, and\n",
" | should not be confused with inplace.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.to_datetime : Convert argument to datetime.\n",
" | pandas.to_timedelta : Convert argument to timedelta.\n",
" | pandas.to_numeric : Return a fixed frequency timedelta index,\n",
" | with day as the default.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | converted : same as input object\n",
" | \n",
" | copy(self, deep=True)\n",
" | Make a copy of this objects data.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | deep : boolean or string, default True\n",
" | Make a deep copy, including a copy of the data and the indices.\n",
" | With ``deep=False`` neither the indices or the data are copied.\n",
" | \n",
" | Note that when ``deep=True`` data is copied, 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.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | copy : type of caller\n",
" | \n",
" | describe(self, percentiles=None, include=None, exclude=None)\n",
" | Generates descriptive statistics that summarize the central tendency,\n",
" | dispersion and shape of a dataset's distribution, excluding\n",
" | ``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(include=['O'])``). To\n",
" | exclude pandas categorical columns, use ``'category'``\n",
" | - None (default) : The result will exclude nothing.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | summary: Series/DataFrame of summary statistics\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",
" | \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",
" | unique 2\n",
" | top 2010-01-01 00:00:00\n",
" | freq 2\n",
" | first 2000-01-01 00:00:00\n",
" | last 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({ 'object': ['a', 'b', 'c'],\n",
" | ... 'numeric': [1, 2, 3],\n",
" | ... 'categorical': pd.Categorical(['d','e','f'])\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')\n",
" | categorical numeric object\n",
" | count 3 3.0 3\n",
" | unique 3 NaN 3\n",
" | top f NaN c\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=[np.object])\n",
" | object\n",
" | count 3\n",
" | unique 3\n",
" | top c\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 f\n",
" | freq 1\n",
" | \n",
" | Excluding numeric columns from a ``DataFrame`` description.\n",
" | \n",
" | >>> df.describe(exclude=[np.number])\n",
" | categorical object\n",
" | count 3 3\n",
" | unique 3 3\n",
" | top f c\n",
" | freq 1 1\n",
" | \n",
" | Excluding object columns from a ``DataFrame`` description.\n",
" | \n",
" | >>> df.describe(exclude=[np.object])\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",
" | See Also\n",
" | --------\n",
" | DataFrame.count\n",
" | DataFrame.max\n",
" | DataFrame.min\n",
" | DataFrame.mean\n",
" | DataFrame.std\n",
" | DataFrame.select_dtypes\n",
" | \n",
" | drop(self, labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')\n",
" | Return new object with labels in requested axis removed.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | labels : single label or list-like\n",
" | Index or column labels to drop.\n",
" | axis : int or axis name\n",
" | Whether to drop labels from the index (0 / 'index') or\n",
" | columns (1 / 'columns').\n",
" | index, columns : single label or list-like\n",
" | Alternative to specifying `axis` (``labels, axis=1`` is\n",
" | equivalent to ``columns=labels``).\n",
" | \n",
" | .. versionadded:: 0.21.0\n",
" | level : int or level name, default None\n",
" | For MultiIndex\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 existing labels are dropped.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | dropped : type of caller\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df = pd.DataFrame(np.arange(12).reshape(3,4),\n",
" | columns=['A', 'B', 'C', 'D'])\n",
" | >>> df\n",
" | A B C D\n",
" | 0 0 1 2 3\n",
" | 1 4 5 6 7\n",
" | 2 8 9 10 11\n",
" | \n",
" | Drop columns\n",
" | \n",
" | >>> df.drop(['B', 'C'], axis=1)\n",
" | A D\n",
" | 0 0 3\n",
" | 1 4 7\n",
" | 2 8 11\n",
" | \n",
" | >>> df.drop(columns=['B', 'C'])\n",
" | A D\n",
" | 0 0 3\n",
" | 1 4 7\n",
" | 2 8 11\n",
" | \n",
" | Drop a row by index\n",
" | \n",
" | >>> df.drop([0, 1])\n",
" | A B C D\n",
" | 2 8 9 10 11\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Specifying both `labels` and `index` or `columns` will raise a\n",
" | ValueError.\n",
" | \n",
" | equals(self, other)\n",
" | Determines if two NDFrame objects contain the same elements. NaNs in\n",
" | the same location are considered equal.\n",
" | \n",
" | ffill(self, axis=None, inplace=False, limit=None, downcast=None)\n",
" | Synonym for :meth:`DataFrame.fillna(method='ffill') `\n",
" | \n",
" | filter(self, items=None, like=None, regex=None, axis=None)\n",
" | Subset rows or columns of dataframe according to labels in\n",
" | the specified index.\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",
" | List of info axis to restrict to (must not all be present)\n",
" | like : string\n",
" | Keep info axis where \"arg in col == True\"\n",
" | regex : string (regular expression)\n",
" | Keep info axis with re.search(regex, col) == True\n",
" | axis : int or string axis name\n",
" | The axis to filter on. By default this is the info axis,\n",
" | 'index' for Series, 'columns' for DataFrame\n",
" | \n",
" | Returns\n",
" | -------\n",
" | same type as input object\n",
" | \n",
" | Examples\n",
" | --------\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",
" | See Also\n",
" | --------\n",
" | pandas.DataFrame.loc\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",
" | first(self, offset)\n",
" | Convenience method for subsetting initial periods of time series data\n",
" | based on a date offset.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | offset : string, DateOffset, dateutil.relativedelta\n",
" | \n",
" | Examples\n",
" | --------\n",
" | ts.first('10D') -> First 10 days\n",
" | \n",
" | Returns\n",
" | -------\n",
" | subset : type of caller\n",
" | \n",
" | get(self, key, default=None)\n",
" | Get item from object for given key (DataFrame column, Panel slice,\n",
" | etc.). Returns default value if not found.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | key : object\n",
" | \n",
" | Returns\n",
" | -------\n",
" | value : type of items contained in object\n",
" | \n",
" | get_dtype_counts(self)\n",
" | Return the counts of dtypes in this object.\n",
" | \n",
" | get_ftype_counts(self)\n",
" | Return the counts of ftypes in this object.\n",
" | \n",
" | get_values(self)\n",
" | same as values (but handles sparseness conversions)\n",
" | \n",
" | groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)\n",
" | Group series using mapper (dict or key function, apply given function\n",
" | to group, return result as series) or by a series of columns.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | by : mapping, function, str, or iterable\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 an ndarray is passed, the\n",
" | values are used as-is determine the groups. A str or list of strs\n",
" | may be passed to group by the columns in ``self``\n",
" | axis : int, default 0\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\n",
" | as_index : boolean, default True\n",
" | For aggregated output, return object with group labels as the\n",
" | index. Only relevant for DataFrame input. as_index=False is\n",
" | effectively \"SQL-style\" grouped output\n",
" | sort : boolean, 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.\n",
" | group_keys : boolean, default True\n",
" | When calling apply, add group keys to index to identify pieces\n",
" | squeeze : boolean, default False\n",
" | reduce the dimensionality of the return type if possible,\n",
" | otherwise return a consistent type\n",
" | \n",
" | Examples\n",
" | --------\n",
" | DataFrame results\n",
" | \n",
" | >>> data.groupby(func, axis=0).mean()\n",
" | >>> data.groupby(['col1', 'col2'])['col3'].mean()\n",
" | \n",
" | DataFrame with hierarchical index\n",
" | \n",
" | >>> data.groupby(['col1', 'col2']).mean()\n",
" | \n",
" | Returns\n",
" | -------\n",
" | GroupBy object\n",
" | \n",
" | head(self, n=5)\n",
" | Return the first n rows.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | n : int, default 5\n",
" | Number of rows to select.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | obj_head : type of caller\n",
" | The first n rows of the caller object.\n",
" | \n",
" | infer_objects(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",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.to_datetime : Convert argument to datetime.\n",
" | pandas.to_timedelta : Convert argument to timedelta.\n",
" | pandas.to_numeric : Convert argument to numeric typeR\n",
" | \n",
" | Returns\n",
" | -------\n",
" | converted : same type as input object\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='linear', axis=0, limit=None, inplace=False, limit_direction='forward', downcast=None, **kwargs)\n",
" | Interpolate values according to different methods.\n",
" | \n",
" | Please note that only ``method='linear'`` is supported for\n",
" | DataFrames/Series with a MultiIndex.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | method : {'linear', 'time', 'index', 'values', 'nearest', 'zero',\n",
" | 'slinear', 'quadratic', 'cubic', 'barycentric', 'krogh',\n",
" | 'polynomial', 'spline', 'piecewise_polynomial',\n",
" | 'from_derivatives', 'pchip', 'akima'}\n",
" | \n",
" | * 'linear': ignore the index and treat the values as equally\n",
" | spaced. This is the only method supported on MultiIndexes.\n",
" | default\n",
" | * 'time': interpolation works on daily and higher resolution\n",
" | data to interpolate given length of interval\n",
" | * 'index', 'values': use the actual numerical values of the index\n",
" | * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',\n",
" | 'barycentric', 'polynomial' is passed to\n",
" | ``scipy.interpolate.interp1d``. Both 'polynomial' and 'spline'\n",
" | require that you also specify an `order` (int),\n",
" | e.g. df.interpolate(method='polynomial', order=4).\n",
" | These use the actual numerical values of the index.\n",
" | * 'krogh', 'piecewise_polynomial', 'spline', 'pchip' and 'akima'\n",
" | are all wrappers around the scipy interpolation methods of\n",
" | similar names. These use the actual numerical values of the\n",
" | index. For more information on their behavior, see the\n",
" | `scipy documentation\n",
" | `__\n",
" | and `tutorial documentation\n",
" | `__\n",
" | * 'from_derivatives' refers to BPoly.from_derivatives which\n",
" | replaces 'piecewise_polynomial' interpolation method in\n",
" | scipy 0.18\n",
" | \n",
" | .. versionadded:: 0.18.1\n",
" | \n",
" | Added support for the 'akima' method\n",
" | Added interpolate method 'from_derivatives' which replaces\n",
" | 'piecewise_polynomial' in scipy 0.18; backwards-compatible with\n",
" | scipy < 0.18\n",
" | \n",
" | axis : {0, 1}, default 0\n",
" | * 0: fill column-by-column\n",
" | * 1: fill row-by-row\n",
" | limit : int, default None.\n",
" | Maximum number of consecutive NaNs to fill. Must be greater than 0.\n",
" | limit_direction : {'forward', 'backward', 'both'}, default 'forward'\n",
" | If limit is specified, consecutive NaNs will be filled in this\n",
" | direction.\n",
" | \n",
" | .. versionadded:: 0.17.0\n",
" | \n",
" | inplace : bool, default False\n",
" | Update the NDFrame in place if possible.\n",
" | downcast : optional, 'infer' or None, defaults to None\n",
" | Downcast dtypes if possible.\n",
" | kwargs : keyword arguments to pass on to the interpolating function.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | Series or DataFrame of same shape interpolated at the NaNs\n",
" | \n",
" | See Also\n",
" | --------\n",
" | reindex, replace, fillna\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | Filling in NaNs\n",
" | \n",
" | >>> s = pd.Series([0, 1, np.nan, 3])\n",
" | >>> s.interpolate()\n",
" | 0 0\n",
" | 1 1\n",
" | 2 2\n",
" | 3 3\n",
" | dtype: float64\n",
" | \n",
" | keys(self)\n",
" | Get the 'info axis' (see Indexing for more)\n",
" | \n",
" | This is index for Series, columns for DataFrame and major_axis for\n",
" | Panel.\n",
" | \n",
" | last(self, offset)\n",
" | Convenience method for subsetting final periods of time series data\n",
" | based on a date offset.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | offset : string, DateOffset, dateutil.relativedelta\n",
" | \n",
" | Examples\n",
" | --------\n",
" | ts.last('5M') -> Last 5 months\n",
" | \n",
" | Returns\n",
" | -------\n",
" | subset : type of caller\n",
" | \n",
" | mask(self, cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False, raise_on_error=None)\n",
" | Return an object of same shape as self and whose corresponding\n",
" | entries are from self where `cond` is False and otherwise are from\n",
" | `other`.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cond : boolean NDFrame, 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 NDFrame and\n",
" | should return boolean NDFrame or array. The callable must\n",
" | not change input NDFrame (though pandas doesn't check it).\n",
" | \n",
" | .. versionadded:: 0.18.1\n",
" | A callable can be used as cond.\n",
" | \n",
" | other : scalar, NDFrame, 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 NDFrame and\n",
" | should return scalar or NDFrame. The callable must not\n",
" | change input NDFrame (though pandas doesn't check it).\n",
" | \n",
" | .. versionadded:: 0.18.1\n",
" | A callable can be used as other.\n",
" | \n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | axis : alignment axis if needed, default None\n",
" | level : alignment level if needed, default None\n",
" | errors : str, {'raise', 'ignore'}, default 'raise'\n",
" | - ``raise`` : allow exceptions to be raised\n",
" | - ``ignore`` : suppress exceptions. On error return original object\n",
" | \n",
" | Note that currently this parameter won't affect\n",
" | the results and will always coerce to a suitable dtype.\n",
" | \n",
" | try_cast : boolean, default False\n",
" | try to cast the result back to the input type (if possible),\n",
" | raise_on_error : boolean, default True\n",
" | Whether to raise on invalid data types (e.g. trying to where on\n",
" | strings)\n",
" | \n",
" | .. deprecated:: 0.21.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | wh : same type as caller\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.\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 `.\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",
" | \n",
" | >>> s.mask(s > 0)\n",
" | 0 0.0\n",
" | 1 NaN\n",
" | 2 NaN\n",
" | 3 NaN\n",
" | 4 NaN\n",
" | \n",
" | >>> s.where(s > 1, 10)\n",
" | 0 10.0\n",
" | 1 10.0\n",
" | 2 2.0\n",
" | 3 3.0\n",
" | 4 4.0\n",
" | \n",
" | >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])\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",
" | See Also\n",
" | --------\n",
" | :func:`DataFrame.where`\n",
" | \n",
" | pct_change(self, periods=1, fill_method='pad', limit=None, freq=None, **kwargs)\n",
" | Percent change over given number of periods.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int, default 1\n",
" | Periods to shift for forming percent change\n",
" | fill_method : str, default 'pad'\n",
" | How to handle NAs before computing percent changes\n",
" | limit : int, default None\n",
" | The number of consecutive NAs to fill before stopping\n",
" | freq : DateOffset, timedelta, or offset alias string, optional\n",
" | Increment to use from time series API (e.g. 'M' or BDay())\n",
" | \n",
" | Returns\n",
" | -------\n",
" | chg : NDFrame\n",
" | \n",
" | Notes\n",
" | -----\n",
" | \n",
" | By default, the percentage change is calculated along the stat\n",
" | axis: 0, or ``Index``, for ``DataFrame`` and 1, or ``minor`` for\n",
" | ``Panel``. You can change this with the ``axis`` keyword argument.\n",
" | \n",
" | pipe(self, func, *args, **kwargs)\n",
" | Apply func(self, \\*args, \\*\\*kwargs)\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | func : function\n",
" | function to apply to the NDFrame.\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 NDFrame.\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",
" | object : the return type of ``func``.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | \n",
" | Use ``.pipe`` when chaining together functions that expect\n",
" | Series, DataFrames or GroupBy objects. Instead of writing\n",
" | \n",
" | >>> f(g(h(df), arg1=a), arg2=b, arg3=c)\n",
" | \n",
" | You can write\n",
" | \n",
" | >>> (df.pipe(h)\n",
" | ... .pipe(g, arg1=a)\n",
" | ... .pipe(f, arg2=b, arg3=c)\n",
" | ... )\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 ``f`` takes its data as ``arg2``:\n",
" | \n",
" | >>> (df.pipe(h)\n",
" | ... .pipe(g, arg1=a)\n",
" | ... .pipe((f, 'arg2'), arg1=a, arg3=c)\n",
" | ... )\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.DataFrame.apply\n",
" | pandas.DataFrame.applymap\n",
" | pandas.Series.map\n",
" | \n",
" | pop(self, item)\n",
" | Return item and drop from frame. Raise KeyError if not found.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | item : str\n",
" | Column label to be popped\n",
" | \n",
" | Returns\n",
" | -------\n",
" | popped : Series\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",
" | >>> df\n",
" | name class max_speed\n",
" | 0 falcon bird 389.0\n",
" | 1 parrot bird 24.0\n",
" | 2 lion mammal 80.5\n",
" | 3 monkey mammal NaN\n",
" | \n",
" | >>> df.pop('class')\n",
" | 0 bird\n",
" | 1 bird\n",
" | 2 mammal\n",
" | 3 mammal\n",
" | Name: class, dtype: object\n",
" | \n",
" | >>> df\n",
" | name max_speed\n",
" | 0 falcon 389.0\n",
" | 1 parrot 24.0\n",
" | 2 lion 80.5\n",
" | 3 monkey NaN\n",
" | \n",
" | rank(self, axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)\n",
" | Compute numerical data ranks (1 through n) along axis. Equal values are\n",
" | assigned a rank that is the average of the ranks of those values\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : {0 or 'index', 1 or 'columns'}, default 0\n",
" | index to direct ranking\n",
" | method : {'average', 'min', 'max', 'first', 'dense'}\n",
" | * average: average rank of group\n",
" | * min: lowest rank in group\n",
" | * max: highest rank in 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",
" | numeric_only : boolean, default None\n",
" | Include only float, int, boolean data. Valid only for DataFrame or\n",
" | Panel objects\n",
" | na_option : {'keep', 'top', 'bottom'}\n",
" | * keep: leave NA values where they are\n",
" | * top: smallest rank if ascending\n",
" | * bottom: smallest rank if descending\n",
" | ascending : boolean, default True\n",
" | False for ranks by high (1) to low (N)\n",
" | pct : boolean, default False\n",
" | Computes percentage rank of data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | ranks : same type as caller\n",
" | \n",
" | reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None)\n",
" | Return an object with matching indices to myself.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | other : Object\n",
" | method : string or None\n",
" | copy : boolean, default True\n",
" | limit : int, default None\n",
" | Maximum number of consecutive labels to fill for inexact matches.\n",
" | tolerance : optional\n",
" | Maximum distance between labels of the other object and this\n",
" | object for inexact matches. Can be list-like.\n",
" | \n",
" | .. versionadded:: 0.17.0\n",
" | .. versionadded:: 0.21.0 (list-like tolerance)\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Like calling s.reindex(index=other.index, columns=other.columns,\n",
" | method=...)\n",
" | \n",
" | Returns\n",
" | -------\n",
" | reindexed : same as input\n",
" | \n",
" | rename_axis(self, mapper, axis=0, copy=True, inplace=False)\n",
" | Alter the name of the index or columns.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | mapper : scalar, list-like, optional\n",
" | Value to set the axis name attribute.\n",
" | axis : int or string, default 0\n",
" | copy : boolean, default True\n",
" | Also copy underlying data\n",
" | inplace : boolean, default False\n",
" | \n",
" | Returns\n",
" | -------\n",
" | renamed : type of caller or None if inplace=True\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Prior to version 0.21.0, ``rename_axis`` could also be used to change\n",
" | the axis *labels* by passing a mapping or scalar. This behavior is\n",
" | deprecated and will be removed in a future version. Use ``rename``\n",
" | instead.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.Series.rename, pandas.DataFrame.rename\n",
" | pandas.Index.rename\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6]})\n",
" | >>> df.rename_axis(\"foo\")\n",
" | A B\n",
" | foo\n",
" | 0 1 4\n",
" | 1 2 5\n",
" | 2 3 6\n",
" | \n",
" | >>> df.rename_axis(\"bar\", axis=\"columns\")\n",
" | bar A B\n",
" | 0 1 4\n",
" | 1 2 5\n",
" | 2 3 6\n",
" | \n",
" | replace(self, to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad', axis=None)\n",
" | Replace values given in 'to_replace' with 'value'.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | to_replace : str, regex, list, dict, Series, numeric, or None\n",
" | \n",
" | * str or regex:\n",
" | \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 and regex rules apply as above.\n",
" | \n",
" | * dict:\n",
" | \n",
" | - Nested dictionaries, e.g., {'a': {'b': nan}}, are read as\n",
" | follows: look in column 'a' for the value 'b' and replace it\n",
" | with nan. 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",
" | - Keys map to column names and values map to substitution\n",
" | values. You can treat this as a special case of passing two\n",
" | lists except that you are specifying the column to search in.\n",
" | \n",
" | * None:\n",
" | \n",
" | - This means that the ``regex`` argument must be a string,\n",
" | compiled regular expression, or list, dict, ndarray or Series\n",
" | of such elements. If `value` is also ``None`` then this\n",
" | **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 use to fill holes (e.g. 0), alternately a dict of values\n",
" | specifying which value to use for each column (columns not in the\n",
" | dict will not be filled). Regular expressions, strings and lists or\n",
" | dicts of such objects are also allowed.\n",
" | inplace : boolean, default False\n",
" | If True, in place. Note: this will modify any\n",
" | other views on this object (e.g. a column from a DataFrame).\n",
" | Returns the caller if this is True.\n",
" | limit : int, default None\n",
" | Maximum size gap to forward or backward fill\n",
" | regex : bool or same types as `to_replace`, default False\n",
" | Whether to interpret `to_replace` and/or `value` as regular\n",
" | expressions. If this is ``True`` then `to_replace` *must* be a\n",
" | string. Otherwise, `to_replace` must be ``None`` because this\n",
" | parameter will be interpreted as a regular expression or a list,\n",
" | dict, or array of regular expressions.\n",
" | method : string, optional, {'pad', 'ffill', 'bfill'}\n",
" | The method to use when for replacement, when ``to_replace`` is a\n",
" | ``list``.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | NDFrame.reindex\n",
" | NDFrame.asfreq\n",
" | NDFrame.fillna\n",
" | \n",
" | Returns\n",
" | -------\n",
" | filled : NDFrame\n",
" | \n",
" | Raises\n",
" | ------\n",
" | AssertionError\n",
" | * If `regex` is not a ``bool`` and `to_replace` is not ``None``.\n",
" | TypeError\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 into a\n",
" | regular expression or is a list, dict, ndarray, or Series.\n",
" | ValueError\n",
" | * If `to_replace` and `value` are ``list`` s or ``ndarray`` s, but\n",
" | they are not the same length.\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 numbers\n",
" | *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",
" | \n",
" | resample(self, rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start', kind=None, loffset=None, limit=None, base=0, on=None, level=None)\n",
" | Convenience method for frequency conversion and resampling of time\n",
" | series. Object must have a datetime-like index (DatetimeIndex,\n",
" | PeriodIndex, or TimedeltaIndex), or pass datetime-like values\n",
" | to the on or level keyword.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | rule : string\n",
" | the offset string or object representing target conversion\n",
" | axis : int, optional, default 0\n",
" | closed : {'right', 'left'}\n",
" | Which side of bin interval is closed. The default is 'left'\n",
" | for all frequency offsets except for 'M', 'A', 'Q', 'BM',\n",
" | 'BA', 'BQ', and 'W' which all have a default of 'right'.\n",
" | label : {'right', 'left'}\n",
" | Which bin edge label to label bucket with. The default is 'left'\n",
" | for all frequency offsets except for 'M', 'A', 'Q', 'BM',\n",
" | 'BA', 'BQ', and 'W' which all have a default of 'right'.\n",
" | convention : {'start', 'end', 's', 'e'}\n",
" | For PeriodIndex only, controls whether to use the start or end of\n",
" | `rule`\n",
" | loffset : timedelta\n",
" | Adjust the resampled time labels\n",
" | base : int, default 0\n",
" | For frequencies that evenly subdivide 1 day, the \"origin\" of the\n",
" | aggregated intervals. For example, for '5min' frequency, base could\n",
" | range from 0 through 4. Defaults to 0\n",
" | on : string, optional\n",
" | For a DataFrame, column to use instead of index for resampling.\n",
" | Column must be datetime-like.\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | level : string or int, optional\n",
" | For a MultiIndex, level (name or number) to use for\n",
" | resampling. Level must be datetime-like.\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | Notes\n",
" | -----\n",
" | To learn more about the offset strings, please see `this link\n",
" | `__.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | Start by creating a series with 9 one minute timestamps.\n",
" | \n",
" | >>> index = pd.date_range('1/1/2000', periods=9, freq='T')\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: T, 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('3T').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: 3T, 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",
" | To include this value close the right side of the bin interval as\n",
" | illustrated in the example below this one.\n",
" | \n",
" | >>> series.resample('3T', 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: 3T, dtype: int64\n",
" | \n",
" | Downsample the series into 3 minute bins as above, but close the right\n",
" | side of the bin interval.\n",
" | \n",
" | >>> series.resample('3T', 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: 3T, 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 ``pad`` method.\n",
" | \n",
" | >>> series.resample('30S').pad()[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(array_like):\n",
" | ... return np.sum(array_like)+5\n",
" | \n",
" | >>> series.resample('3T').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: 3T, dtype: int64\n",
" | \n",
" | For a Series with a PeriodIndex, the keyword `convention` can be\n",
" | used to control whether to use the start or end of `rule`.\n",
" | \n",
" | >>> s = pd.Series([1, 2], index=pd.period_range('2012-01-01',\n",
" | freq='A',\n",
" | periods=2))\n",
" | >>> s\n",
" | 2012 1\n",
" | 2013 2\n",
" | Freq: A-DEC, dtype: int64\n",
" | \n",
" | Resample by month using 'start' `convention`. Values are assigned to\n",
" | the first month of the period.\n",
" | \n",
" | >>> s.resample('M', convention='start').asfreq().head()\n",
" | 2012-01 1.0\n",
" | 2012-02 NaN\n",
" | 2012-03 NaN\n",
" | 2012-04 NaN\n",
" | 2012-05 NaN\n",
" | Freq: M, dtype: float64\n",
" | \n",
" | Resample by month using 'end' `convention`. Values are assigned to\n",
" | the last month of the period.\n",
" | \n",
" | >>> s.resample('M', convention='end').asfreq()\n",
" | 2012-12 1.0\n",
" | 2013-01 NaN\n",
" | 2013-02 NaN\n",
" | 2013-03 NaN\n",
" | 2013-04 NaN\n",
" | 2013-05 NaN\n",
" | 2013-06 NaN\n",
" | 2013-07 NaN\n",
" | 2013-08 NaN\n",
" | 2013-09 NaN\n",
" | 2013-10 NaN\n",
" | 2013-11 NaN\n",
" | 2013-12 2.0\n",
" | Freq: M, dtype: float64\n",
" | \n",
" | For DataFrame objects, the keyword ``on`` can be used to specify the\n",
" | column instead of the index for resampling.\n",
" | \n",
" | >>> df = pd.DataFrame(data=9*[range(4)], columns=['a', 'b', 'c', 'd'])\n",
" | >>> df['time'] = pd.date_range('1/1/2000', periods=9, freq='T')\n",
" | >>> df.resample('3T', on='time').sum()\n",
" | a b c d\n",
" | time\n",
" | 2000-01-01 00:00:00 0 3 6 9\n",
" | 2000-01-01 00:03:00 0 3 6 9\n",
" | 2000-01-01 00:06:00 0 3 6 9\n",
" | \n",
" | For a DataFrame with MultiIndex, the keyword ``level`` can be used to\n",
" | specify on level the resampling needs to take place.\n",
" | \n",
" | >>> time = pd.date_range('1/1/2000', periods=5, freq='T')\n",
" | >>> df2 = pd.DataFrame(data=10*[range(4)],\n",
" | columns=['a', 'b', 'c', 'd'],\n",
" | index=pd.MultiIndex.from_product([time, [1, 2]])\n",
" | )\n",
" | >>> df2.resample('3T', level=0).sum()\n",
" | a b c d\n",
" | 2000-01-01 00:00:00 0 6 12 18\n",
" | 2000-01-01 00:03:00 0 4 8 12\n",
" | \n",
" | sample(self, n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)\n",
" | Returns a random sample of items from an axis of object.\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 : boolean, optional\n",
" | Sample with or without replacement. Default = False.\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",
" | inf and -inf values not allowed.\n",
" | random_state : int or numpy.random.RandomState, optional\n",
" | Seed for the random number generator (if int), or numpy RandomState\n",
" | object.\n",
" | axis : int or string, optional\n",
" | Axis to sample. Accepts axis number or name. Default is stat axis\n",
" | for given data type (0 for Series and DataFrames, 1 for Panels).\n",
" | \n",
" | Returns\n",
" | -------\n",
" | A new object of same type as caller.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | Generate an example ``Series`` and ``DataFrame``:\n",
" | \n",
" | >>> s = pd.Series(np.random.randn(50))\n",
" | >>> s.head()\n",
" | 0 -0.038497\n",
" | 1 1.820773\n",
" | 2 -0.972766\n",
" | 3 -1.598270\n",
" | 4 -1.095526\n",
" | dtype: float64\n",
" | >>> df = pd.DataFrame(np.random.randn(50, 4), columns=list('ABCD'))\n",
" | >>> df.head()\n",
" | A B C D\n",
" | 0 0.016443 -2.318952 -0.566372 -1.028078\n",
" | 1 -1.051921 0.438836 0.658280 -0.175797\n",
" | 2 -1.243569 -0.364626 -0.215065 0.057736\n",
" | 3 1.768216 0.404512 -0.385604 -1.457834\n",
" | 4 1.072446 -1.137172 0.314194 -0.046661\n",
" | \n",
" | Next extract a random sample from both of these objects...\n",
" | \n",
" | 3 random elements from the ``Series``:\n",
" | \n",
" | >>> s.sample(n=3)\n",
" | 27 -0.994689\n",
" | 55 -1.049016\n",
" | 67 -0.224565\n",
" | dtype: float64\n",
" | \n",
" | And a random 10% of the ``DataFrame`` with replacement:\n",
" | \n",
" | >>> df.sample(frac=0.1, replace=True)\n",
" | A B C D\n",
" | 35 1.981780 0.142106 1.817165 -0.290805\n",
" | 49 -1.336199 -0.448634 -0.789640 0.217116\n",
" | 40 0.823173 -0.078816 1.009536 1.015108\n",
" | 15 1.421154 -0.055301 -1.922594 -0.019696\n",
" | 6 -0.148339 0.832938 1.787600 -1.383767\n",
" | \n",
" | select(self, crit, axis=0)\n",
" | Return data corresponding to axis labels matching criteria\n",
" | \n",
" | DEPRECATED: use df.loc[df.index.map(crit)] to select via labels\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | crit : function\n",
" | To be called on each index (label). Should return True or False\n",
" | axis : int\n",
" | \n",
" | Returns\n",
" | -------\n",
" | selection : type of caller\n",
" | \n",
" | set_axis(self, labels, axis=0, inplace=None)\n",
" | Assign desired index to given axis\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | labels: list-like or Index\n",
" | The values for the new index\n",
" | axis : int or string, default 0\n",
" | inplace : boolean, default None\n",
" | Whether to return a new NDFrame instance.\n",
" | \n",
" | WARNING: inplace=None currently falls back to to True, but\n",
" | in a future version, will default to False. Use inplace=True\n",
" | explicitly rather than relying on the default.\n",
" | \n",
" | .. versionadded:: 0.21.0\n",
" | The signature is make consistent to the rest of the API.\n",
" | Previously, the \"axis\" and \"labels\" arguments were respectively\n",
" | the first and second positional arguments.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | renamed : NDFrame or None\n",
" | An object of same type as caller if inplace=False, None otherwise.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pandas.NDFrame.rename\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.set_axis(['a', 'b', 'c'], axis=0, inplace=False)\n",
" | a 1\n",
" | b 2\n",
" | c 3\n",
" | dtype: int64\n",
" | >>> df = pd.DataFrame({\"A\": [1, 2, 3], \"B\": [4, 5, 6]})\n",
" | >>> df.set_axis(['a', 'b', 'c'], axis=0, inplace=False)\n",
" | A B\n",
" | a 1 4\n",
" | b 2 5\n",
" | c 3 6\n",
" | >>> df.set_axis(['I', 'II'], axis=1, inplace=False)\n",
" | I II\n",
" | 0 1 4\n",
" | 1 2 5\n",
" | 2 3 6\n",
" | >>> df.set_axis(['i', 'ii'], axis=1, inplace=True)\n",
" | >>> df\n",
" | i ii\n",
" | 0 1 4\n",
" | 1 2 5\n",
" | 2 3 6\n",
" | \n",
" | slice_shift(self, periods=1, axis=0)\n",
" | Equivalent to `shift` without copying data. The shifted data will\n",
" | not include the dropped periods and the shifted axis will be smaller\n",
" | than the original.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int\n",
" | Number of periods to move, can be positive or negative\n",
" | \n",
" | Notes\n",
" | -----\n",
" | While the `slice_shift` is faster than `shift`, you may pay for it\n",
" | later during alignment.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | shifted : same type as caller\n",
" | \n",
" | squeeze(self, axis=None)\n",
" | Squeeze length 1 dimensions.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | axis : None, integer or string axis name, optional\n",
" | The axis to squeeze if 1-sized.\n",
" | \n",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | scalar if 1-sized, else original object\n",
" | \n",
" | swapaxes(self, axis1, axis2, copy=True)\n",
" | Interchange axes and swap values axes appropriately\n",
" | \n",
" | Returns\n",
" | -------\n",
" | y : same as input\n",
" | \n",
" | tail(self, n=5)\n",
" | Return the last n rows.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | n : int, default 5\n",
" | Number of rows to select.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | obj_tail : type of caller\n",
" | The last n rows of the caller object.\n",
" | \n",
" | take(self, indices, axis=0, convert=None, is_copy=True, **kwargs)\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 : int, 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, etc.\n",
" | convert : bool, default True\n",
" | .. deprecated:: 0.21.0\n",
" | In the future, negative indices will always be converted.\n",
" | \n",
" | Whether to convert negative indices into positive ones.\n",
" | For example, ``-1`` would map to the ``len(axis) - 1``.\n",
" | The conversions are similar to the behavior of indexing a\n",
" | regular Python list.\n",
" | is_copy : bool, default True\n",
" | Whether to return a copy of the original object or not.\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",
" | 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",
" | Returns\n",
" | -------\n",
" | taken : type of caller\n",
" | An array-like containing the elements taken from the object.\n",
" | \n",
" | See Also\n",
" | --------\n",
" | numpy.ndarray.take\n",
" | numpy.take\n",
" | \n",
" | to_clipboard(self, excel=None, sep=None, **kwargs)\n",
" | Attempt to write text representation of object to the system clipboard\n",
" | This can be pasted into Excel, for example.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | excel : boolean, defaults to True\n",
" | if True, use the provided separator, writing in a csv\n",
" | format for allowing easy pasting into excel.\n",
" | if False, write a string representation of the object\n",
" | to the clipboard\n",
" | sep : optional, defaults to tab\n",
" | other keywords are passed to to_csv\n",
" | \n",
" | Notes\n",
" | -----\n",
" | Requirements for your platform\n",
" | - Linux: xclip, or xsel (with gtk or PyQt4 modules)\n",
" | - Windows: none\n",
" | - OS X: none\n",
" | \n",
" | to_dense(self)\n",
" | Return dense representation of NDFrame (as opposed to sparse)\n",
" | \n",
" | to_hdf(self, path_or_buf, key, **kwargs)\n",
" | Write the contained data to an HDF5 file using HDFStore.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path_or_buf : the path (string) or HDFStore object\n",
" | key : string\n",
" | identifier for the group in the store\n",
" | mode : optional, {'a', 'w', 'r+'}, default 'a'\n",
" | \n",
" | ``'w'``\n",
" | Write; a new file is created (an existing file with the same\n",
" | name would be deleted).\n",
" | ``'a'``\n",
" | Append; an existing file is opened for reading and writing,\n",
" | and if the file does not exist it is created.\n",
" | ``'r+'``\n",
" | It is similar to ``'a'``, but the file must already exist.\n",
" | format : 'fixed(f)|table(t)', default is 'fixed'\n",
" | fixed(f) : Fixed format\n",
" | Fast writing/reading. Not-appendable, nor searchable\n",
" | table(t) : Table format\n",
" | Write as a PyTables Table structure which may perform\n",
" | worse but allow more flexible operations like searching\n",
" | / selecting subsets of the data\n",
" | append : boolean, default False\n",
" | For Table formats, append the input data to the existing\n",
" | data_columns : list of columns, or True, default None\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 `here\n",
" | `__.\n",
" | \n",
" | Applicable only to format='table'.\n",
" | complevel : int, 0-9, default None\n",
" | Specifies a compression level for data.\n",
" | A value of 0 disables compression.\n",
" | complib : {'zlib', 'lzo', 'bzip2', 'blosc'}, default 'zlib'\n",
" | Specifies the compression library to be used.\n",
" | As of v0.20.2 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",
" | fletcher32 : bool, default False\n",
" | If applying compression use the fletcher32 checksum\n",
" | dropna : boolean, default False.\n",
" | If true, ALL nan rows will not be written to store.\n",
" | \n",
" | to_json(self, path_or_buf=None, orient=None, date_format=None, double_precision=10, force_ascii=True, date_unit='ms', default_handler=None, lines=False, compression=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 : the path or buffer to write the result string\n",
" | if this is None, return the converted string\n",
" | orient : string\n",
" | \n",
" | * Series\n",
" | \n",
" | - default is 'index'\n",
" | - allowed values are: {'split','records','index'}\n",
" | \n",
" | * DataFrame\n",
" | \n",
" | - default is 'columns'\n",
" | - allowed values are:\n",
" | {'split','records','index','columns','values'}\n",
" | \n",
" | * The format of the JSON string\n",
" | \n",
" | - split : dict like\n",
" | {index -> [index], columns -> [columns], data -> [values]}\n",
" | - records : list like\n",
" | [{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",
" | describing the data, and the data component is\n",
" | like ``orient='records'``.\n",
" | \n",
" | .. versionchanged:: 0.20.0\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 : The number of decimal places to use when encoding\n",
" | floating point values, default 10.\n",
" | force_ascii : force encoded string to be ASCII, default True.\n",
" | date_unit : string, 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 : boolean, default False\n",
" | If 'orient' is 'records' write out line delimited json format. Will\n",
" | throw ValueError if incorrect 'orient' since others are not list\n",
" | like.\n",
" | \n",
" | .. versionadded:: 0.19.0\n",
" | \n",
" | compression : {None, 'gzip', 'bz2', 'xz'}\n",
" | A string representing the compression to use in the output file,\n",
" | only used when the first argument is a filename\n",
" | \n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | same type as input object with filtered info axis\n",
" | \n",
" | See Also\n",
" | --------\n",
" | pd.read_json\n",
" | \n",
" | Examples\n",
" | --------\n",
" | \n",
" | >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],\n",
" | ... index=['row 1', 'row 2'],\n",
" | ... columns=['col 1', 'col 2'])\n",
" | >>> df.to_json(orient='split')\n",
" | '{\"columns\":[\"col 1\",\"col 2\"],\n",
" | \"index\":[\"row 1\",\"row 2\"],\n",
" | \"data\":[[\"a\",\"b\"],[\"c\",\"d\"]]}'\n",
" | \n",
" | Encoding/decoding a Dataframe using ``'index'`` formatted JSON:\n",
" | \n",
" | >>> df.to_json(orient='index')\n",
" | '{\"row 1\":{\"col 1\":\"a\",\"col 2\":\"b\"},\"row 2\":{\"col 1\":\"c\",\"col 2\":\"d\"}}'\n",
" | \n",
" | Encoding/decoding a Dataframe using ``'records'`` formatted JSON.\n",
" | Note that index labels are not preserved with this encoding.\n",
" | \n",
" | >>> df.to_json(orient='records')\n",
" | '[{\"col 1\":\"a\",\"col 2\":\"b\"},{\"col 1\":\"c\",\"col 2\":\"d\"}]'\n",
" | \n",
" | Encoding with Table Schema\n",
" | \n",
" | >>> df.to_json(orient='table')\n",
" | '{\"schema\": {\"fields\": [{\"name\": \"index\", \"type\": \"string\"},\n",
" | {\"name\": \"col 1\", \"type\": \"string\"},\n",
" | {\"name\": \"col 2\", \"type\": \"string\"}],\n",
" | \"primaryKey\": \"index\",\n",
" | \"pandas_version\": \"0.20.0\"},\n",
" | \"data\": [{\"index\": \"row 1\", \"col 1\": \"a\", \"col 2\": \"b\"},\n",
" | {\"index\": \"row 2\", \"col 1\": \"c\", \"col 2\": \"d\"}]}'\n",
" | \n",
" | to_latex(self, buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=False, column_format=None, longtable=None, escape=None, encoding=None, decimal='.', multicolumn=None, multicolumn_format=None, multirow=None)\n",
" | Render an object to a tabular environment table. You can splice\n",
" | this into a LaTeX document. Requires \\\\usepackage{booktabs}.\n",
" | \n",
" | .. versionchanged:: 0.20.2\n",
" | Added to Series\n",
" | \n",
" | `to_latex`-specific options:\n",
" | \n",
" | bold_rows : boolean, default False\n",
" | Make the row labels bold in the output\n",
" | column_format : str, default None\n",
" | The columns format as specified in `LaTeX table format\n",
" | `__ e.g 'rcl' for 3\n",
" | columns\n",
" | longtable : boolean, default will be read from the pandas config module\n",
" | Default: False.\n",
" | Use a longtable environment instead of tabular. Requires adding\n",
" | a \\\\usepackage{longtable} to your LaTeX preamble.\n",
" | escape : boolean, default will be read from the pandas config module\n",
" | Default: True.\n",
" | When set to False prevents from escaping latex special\n",
" | characters in column names.\n",
" | encoding : str, default None\n",
" | A string representing the encoding to use in the output file,\n",
" | defaults to 'ascii' on Python 2 and 'utf-8' on Python 3.\n",
" | decimal : string, default '.'\n",
" | Character recognized as decimal separator, e.g. ',' in Europe.\n",
" | \n",
" | .. versionadded:: 0.18.0\n",
" | \n",
" | multicolumn : boolean, default True\n",
" | Use \\multicolumn to enhance MultiIndex columns.\n",
" | The default will be read from the config module.\n",
" | \n",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | multicolumn_format : str, default 'l'\n",
" | The alignment for multicolumns, similar to `column_format`\n",
" | The default will be read from the config module.\n",
" | \n",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | multirow : boolean, default False\n",
" | Use \\multirow to enhance MultiIndex rows.\n",
" | Requires adding a \\\\usepackage{multirow} to your LaTeX preamble.\n",
" | Will print centered labels (instead of top-aligned)\n",
" | across the contained rows, separating groups via clines.\n",
" | The default will be read from the pandas config module.\n",
" | \n",
" | .. versionadded:: 0.20.0\n",
" | \n",
" | to_msgpack(self, path_or_buf=None, encoding='utf-8', **kwargs)\n",
" | msgpack (serialize) object to input file path\n",
" | \n",
" | THIS IS AN EXPERIMENTAL LIBRARY and the storage format\n",
" | may not be stable until a future release.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path : string File path, buffer-like, or None\n",
" | if None, return generated string\n",
" | append : boolean whether to append to an existing msgpack\n",
" | (default is False)\n",
" | compress : type of compressor (zlib or blosc), default to None (no\n",
" | compression)\n",
" | \n",
" | to_pickle(self, path, compression='infer', protocol=4)\n",
" | Pickle (serialize) object to input file path.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | path : string\n",
" | File path\n",
" | compression : {'infer', 'gzip', 'bz2', 'xz', None}, default 'infer'\n",
" | a string representing the compression to use in the output file\n",
" | \n",
" | .. versionadded:: 0.20.0\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 for this parameter depend on the version of Python. For\n",
" | Python 2.x, possible values are 0, 1, 2. For Python>=3.0, 3 is a\n",
" | valid value. For Python >= 3.4, 4 is a valid value.A negative value\n",
" | for the protocol parameter is equivalent to setting its value to\n",
" | HIGHEST_PROTOCOL.\n",
" | \n",
" | .. [1] https://docs.python.org/3/library/pickle.html\n",
" | .. versionadded:: 0.21.0\n",
" | \n",
" | to_sql(self, name, con, flavor=None, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None)\n",
" | Write records stored in a DataFrame to a SQL database.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | name : string\n",
" | Name of SQL table\n",
" | con : SQLAlchemy engine or DBAPI2 connection (legacy mode)\n",
" | Using SQLAlchemy makes it possible to use any DB supported by that\n",
" | library. If a DBAPI2 object, only sqlite3 is supported.\n",
" | flavor : 'sqlite', default None\n",
" | .. deprecated:: 0.19.0\n",
" | 'sqlite' is the only supported option if SQLAlchemy is not\n",
" | used.\n",
" | schema : string, default None\n",
" | Specify the schema (if database flavor supports this). If None, use\n",
" | default schema.\n",
" | if_exists : {'fail', 'replace', 'append'}, default 'fail'\n",
" | - fail: If table exists, do nothing.\n",
" | - replace: If table exists, drop it, recreate it, and insert data.\n",
" | - append: If table exists, insert data. Create if does not exist.\n",
" | index : boolean, default True\n",
" | Write DataFrame index as a column.\n",
" | index_label : string 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, default None\n",
" | If not None, then rows will be written in batches of this size at a\n",
" | time. If None, all rows will be written at once.\n",
" | dtype : dict of column name to SQL type, default None\n",
" | Optional specifying the datatype for columns. The SQL type should\n",
" | be a SQLAlchemy type, or a string for sqlite3 fallback connection.\n",
" | \n",
" | to_xarray(self)\n",
" | Return an xarray object from the pandas object.\n",
" | \n",
" | Returns\n",
" | -------\n",
" | a DataArray for a Series\n",
" | a Dataset for a DataFrame\n",
" | a DataArray for higher dims\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df = pd.DataFrame({'A' : [1, 1, 2],\n",
" | 'B' : ['foo', 'bar', 'foo'],\n",
" | 'C' : np.arange(4.,7)})\n",
" | >>> df\n",
" | A B C\n",
" | 0 1 foo 4.0\n",
" | 1 1 bar 5.0\n",
" | 2 2 foo 6.0\n",
" | \n",
" | >>> df.to_xarray()\n",
" | \n",
" | Dimensions: (index: 3)\n",
" | Coordinates:\n",
" | * index (index) int64 0 1 2\n",
" | Data variables:\n",
" | A (index) int64 1 1 2\n",
" | B (index) object 'foo' 'bar' 'foo'\n",
" | C (index) float64 4.0 5.0 6.0\n",
" | \n",
" | >>> df = pd.DataFrame({'A' : [1, 1, 2],\n",
" | 'B' : ['foo', 'bar', 'foo'],\n",
" | 'C' : np.arange(4.,7)}\n",
" | ).set_index(['B','A'])\n",
" | >>> df\n",
" | C\n",
" | B A\n",
" | foo 1 4.0\n",
" | bar 1 5.0\n",
" | foo 2 6.0\n",
" | \n",
" | >>> df.to_xarray()\n",
" | \n",
" | Dimensions: (A: 2, B: 2)\n",
" | Coordinates:\n",
" | * B (B) object 'bar' 'foo'\n",
" | * A (A) int64 1 2\n",
" | Data variables:\n",
" | C (B, A) float64 5.0 nan 4.0 6.0\n",
" | \n",
" | >>> p = pd.Panel(np.arange(24).reshape(4,3,2),\n",
" | items=list('ABCD'),\n",
" | major_axis=pd.date_range('20130101', periods=3),\n",
" | minor_axis=['first', 'second'])\n",
" | >>> p\n",
" | \n",
" | Dimensions: 4 (items) x 3 (major_axis) x 2 (minor_axis)\n",
" | Items axis: A to D\n",
" | Major_axis axis: 2013-01-01 00:00:00 to 2013-01-03 00:00:00\n",
" | Minor_axis axis: first to second\n",
" | \n",
" | >>> p.to_xarray()\n",
" | \n",
" | array([[[ 0, 1],\n",
" | [ 2, 3],\n",
" | [ 4, 5]],\n",
" | [[ 6, 7],\n",
" | [ 8, 9],\n",
" | [10, 11]],\n",
" | [[12, 13],\n",
" | [14, 15],\n",
" | [16, 17]],\n",
" | [[18, 19],\n",
" | [20, 21],\n",
" | [22, 23]]])\n",
" | Coordinates:\n",
" | * items (items) object 'A' 'B' 'C' 'D'\n",
" | * major_axis (major_axis) datetime64[ns] 2013-01-01 2013-01-02 2013-01-03 # noqa\n",
" | * minor_axis (minor_axis) object 'first' 'second'\n",
" | \n",
" | Notes\n",
" | -----\n",
" | See the `xarray docs `__\n",
" | \n",
" | truncate(self, before=None, after=None, axis=None, copy=True)\n",
" | Truncates a sorted DataFrame/Series before and/or after some\n",
" | particular index value. If the axis contains only datetime values,\n",
" | before/after parameters are converted to datetime values.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | before : date, string, int\n",
" | Truncate all rows before this index value\n",
" | after : date, string, int\n",
" | Truncate all rows after this index value\n",
" | axis : {0 or 'index', 1 or 'columns'}\n",
" | \n",
" | * 0 or 'index': apply truncation to rows\n",
" | * 1 or 'columns': apply truncation to columns\n",
" | Default is stat axis for given data type (0 for Series and\n",
" | DataFrames, 1 for Panels)\n",
" | copy : boolean, default is True,\n",
" | return a copy of the truncated section\n",
" | \n",
" | Returns\n",
" | -------\n",
" | truncated : type of caller\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.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",
" | >>> df = pd.DataFrame({'A': [1, 2, 3, 4, 5],\n",
" | ... 'B': [6, 7, 8, 9, 10],\n",
" | ... 'C': [11, 12, 13, 14, 15]},\n",
" | ... index=['a', 'b', 'c', 'd', 'e'])\n",
" | >>> df.truncate(before='b', after='d')\n",
" | A B C\n",
" | b 2 7 12\n",
" | c 3 8 13\n",
" | d 4 9 14\n",
" | \n",
" | The index values in ``truncate`` can be datetimes or string\n",
" | dates. Note that ``truncate`` assumes a 0 value for any unspecified\n",
" | date component in a ``DatetimeIndex`` in contrast to slicing which\n",
" | returns any partially matching 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.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",
" | >>> 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",
" | tshift(self, periods=1, freq=None, axis=0)\n",
" | Shift the time index, using the index's frequency if available.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | periods : int\n",
" | Number of periods to move, can be positive or negative\n",
" | freq : DateOffset, timedelta, or time rule string, default None\n",
" | Increment to use from the tseries module or time rule (e.g. 'EOM')\n",
" | axis : int or basestring\n",
" | Corresponds to the axis that contains the Index\n",
" | \n",
" | Notes\n",
" | -----\n",
" | If freq is not specified then tries to use the freq or inferred_freq\n",
" | attributes of the index. If neither of those attributes exist, a\n",
" | ValueError is thrown\n",
" | \n",
" | Returns\n",
" | -------\n",
" | shifted : NDFrame\n",
" | \n",
" | tz_convert(self, tz, axis=0, level=None, copy=True)\n",
" | Convert tz-aware axis to target time zone.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | tz : string or pytz.timezone object\n",
" | axis : the axis to convert\n",
" | level : int, str, default None\n",
" | If axis ia a MultiIndex, convert a specific level. Otherwise\n",
" | must be None\n",
" | copy : boolean, default True\n",
" | Also make a copy of the underlying data\n",
" | \n",
" | Returns\n",
" | -------\n",
" | \n",
" | Raises\n",
" | ------\n",
" | TypeError\n",
" | If the axis is tz-naive.\n",
" | \n",
" | tz_localize(self, tz, axis=0, level=None, copy=True, ambiguous='raise')\n",
" | Localize tz-naive TimeSeries to target time zone.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | tz : string or pytz.timezone object\n",
" | axis : 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 : boolean, default True\n",
" | Also make a copy of the underlying data\n",
" | ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'\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",
" | infer_dst : boolean, default False\n",
" | .. deprecated:: 0.15.0\n",
" | Attempt to infer fall dst-transition hours based on order\n",
" | \n",
" | Returns\n",
" | -------\n",
" | \n",
" | Raises\n",
" | ------\n",
" | TypeError\n",
" | If the TimeSeries is tz-aware and tz is not None.\n",
" | \n",
" | where(self, cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False, raise_on_error=None)\n",
" | Return an object of same shape as self and whose corresponding\n",
" | entries are from self where `cond` is True and otherwise are from\n",
" | `other`.\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | cond : boolean NDFrame, 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 NDFrame and\n",
" | should return boolean NDFrame or array. The callable must\n",
" | not change input NDFrame (though pandas doesn't check it).\n",
" | \n",
" | .. versionadded:: 0.18.1\n",
" | A callable can be used as cond.\n",
" | \n",
" | other : scalar, NDFrame, 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 NDFrame and\n",
" | should return scalar or NDFrame. The callable must not\n",
" | change input NDFrame (though pandas doesn't check it).\n",
" | \n",
" | .. versionadded:: 0.18.1\n",
" | A callable can be used as other.\n",
" | \n",
" | inplace : boolean, default False\n",
" | Whether to perform the operation in place on the data\n",
" | axis : alignment axis if needed, default None\n",
" | level : alignment level if needed, default None\n",
" | errors : str, {'raise', 'ignore'}, default 'raise'\n",
" | - ``raise`` : allow exceptions to be raised\n",
" | - ``ignore`` : suppress exceptions. On error return original object\n",
" | \n",
" | Note that currently this parameter won't affect\n",
" | the results and will always coerce to a suitable dtype.\n",
" | \n",
" | try_cast : boolean, default False\n",
" | try to cast the result back to the input type (if possible),\n",
" | raise_on_error : boolean, default True\n",
" | Whether to raise on invalid data types (e.g. trying to where on\n",
" | strings)\n",
" | \n",
" | .. deprecated:: 0.21.0\n",
" | \n",
" | Returns\n",
" | -------\n",
" | wh : same type as caller\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.\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 `.\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",
" | \n",
" | >>> s.mask(s > 0)\n",
" | 0 0.0\n",
" | 1 NaN\n",
" | 2 NaN\n",
" | 3 NaN\n",
" | 4 NaN\n",
" | \n",
" | >>> s.where(s > 1, 10)\n",
" | 0 10.0\n",
" | 1 10.0\n",
" | 2 2.0\n",
" | 3 3.0\n",
" | 4 4.0\n",
" | \n",
" | >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])\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",
" | See Also\n",
" | --------\n",
" | :func:`DataFrame.mask`\n",
" | \n",
" | xs(self, key, axis=0, level=None, drop_level=True)\n",
" | Returns a cross-section (row(s) or column(s)) from the\n",
" | Series/DataFrame. Defaults to cross-section on the rows (axis=0).\n",
" | \n",
" | Parameters\n",
" | ----------\n",
" | key : object\n",
" | Some label contained in the index, or partially in a MultiIndex\n",
" | axis : int, 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 : boolean, default True\n",
" | If False, returns object with same levels as self.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | >>> df\n",
" | A B C\n",
" | a 4 5 2\n",
" | b 4 0 9\n",
" | c 9 7 3\n",
" | >>> df.xs('a')\n",
" | A 4\n",
" | B 5\n",
" | C 2\n",
" | Name: a\n",
" | >>> df.xs('C', axis=1)\n",
" | a 2\n",
" | b 9\n",
" | c 3\n",
" | Name: C\n",
" | \n",
" | >>> df\n",
" | A B C D\n",
" | first second third\n",
" | bar one 1 4 1 8 9\n",
" | two 1 7 5 5 0\n",
" | baz one 1 6 6 8 0\n",
" | three 2 5 3 5 3\n",
" | >>> df.xs(('baz', 'three'))\n",
" | A B C D\n",
" | third\n",
" | 2 5 3 5 3\n",
" | >>> df.xs('one', level=1)\n",
" | A B C D\n",
" | first third\n",
" | bar 1 4 1 8 9\n",
" | baz 1 6 6 8 0\n",
" | >>> df.xs(('baz', 2), level=[0, 'third'])\n",
" | A B C D\n",
" | second\n",
" | three 5 3 5 3\n",
" | \n",
" | Returns\n",
" | -------\n",
" | xs : Series or DataFrame\n",
" | \n",
" | Notes\n",
" | -----\n",
" | xs is only for getting, not setting values.\n",
" | \n",
" | MultiIndex Slicers is a generic way to get/set values on any level or\n",
" | levels. It is a superset of xs functionality, see\n",
" | :ref:`MultiIndex Slicers `\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from pandas.core.generic.NDFrame:\n",
" | \n",
" | at\n",
" | Fast label-based scalar accessor\n",
" | \n",
" | Similarly to ``loc``, ``at`` provides **label** based scalar lookups.\n",
" | You can also set using these indexers.\n",
" | \n",
" | blocks\n",
" | Internal property, property synonym for as_blocks()\n",
" | \n",
" | .. deprecated:: 0.21.0\n",
" | \n",
" | dtypes\n",
" | Return the dtypes in this object.\n",
" | \n",
" | empty\n",
" | True if NDFrame is entirely empty [no items], meaning any of the\n",
" | axes are of length 0.\n",
" | \n",
" | Notes\n",
" | -----\n",
" | If NDFrame contains only NaNs, it is still not considered empty. See\n",
" | the example below.\n",
" | \n",
" | Examples\n",
" | --------\n",
" | An example of an actual empty DataFrame. Notice the index is empty:\n",
" | \n",
" | >>> df_empty = pd.DataFrame({'A' : []})\n",
" | >>> df_empty\n",
" | Empty DataFrame\n",
" | Columns: [A]\n",
" | Index: []\n",
" | >>> df_empty.empty\n",
" | True\n",
" | \n",
" | If we only have NaNs in our DataFrame, it is not considered empty! We\n",
" | will need to drop the NaNs to make the DataFrame empty:\n",
" | \n",
" | >>> df = pd.DataFrame({'A' : [np.nan]})\n",
" | >>> df\n",
" | A\n",
" | 0 NaN\n",
" | >>> df.empty\n",
" | False\n",
" | >>> df.dropna().empty\n",
" | True\n",
" | \n",
" | See also\n",
" | --------\n",
" | pandas.Series.dropna\n",
" | pandas.DataFrame.dropna\n",
" | \n",
" | ftypes\n",
" | Return the ftypes (indication of sparse/dense and dtype)\n",
" | in this object.\n",
" | \n",
" | iat\n",
" | Fast integer location scalar accessor.\n",
" | \n",
" | Similarly to ``iloc``, ``iat`` provides **integer** based lookups.\n",
" | You can also set using these indexers.\n",
" | \n",
" | iloc\n",
" | Purely integer-location based indexing for selection by position.\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, DataFrame\n",
" | or Panel) and that returns valid output for indexing (one of the above)\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 `\n",
" | \n",
" | ix\n",
" | A primarily label-location based indexer, with integer position\n",
" | fallback.\n",
" | \n",
" | ``.ix[]`` supports mixed integer and label based access. It is\n",
" | primarily label based, but will fall back to integer positional\n",
" | access unless the corresponding axis is of integer type.\n",
" | \n",
" | ``.ix`` is the most general indexer and will support any of the\n",
" | inputs in ``.loc`` and ``.iloc``. ``.ix`` also supports floating\n",
" | point label schemes. ``.ix`` is exceptionally useful when dealing\n",
" | with mixed positional and label based hierachical indexes.\n",
" | \n",
" | However, when an axis is integer based, ONLY label based access\n",
" | and not positional access is supported. Thus, in such cases, it's\n",
" | usually better to be explicit and use ``.iloc`` or ``.loc``.\n",
" | \n",
" | See more at :ref:`Advanced Indexing `.\n",
" | \n",
" | loc\n",
" | Purely label-location based indexer for selection by label.\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'`` (note that contrary\n",
" | to usual python slices, **both** the start and the stop are included!).\n",
" | - A boolean array.\n",
" | - A ``callable`` function with one argument (the calling Series, DataFrame\n",
" | or Panel) and that returns valid output for indexing (one of the above)\n",
" | \n",
" | ``.loc`` will raise a ``KeyError`` when the items are not found.\n",
" | \n",
" | See more at :ref:`Selection by Label `\n",
" | \n",
" | ndim\n",
" | Number of axes / array dimensions\n",
" | \n",
" | size\n",
" | number of elements in the NDFrame\n",
" | \n",
" | values\n",
" | Numpy representation of NDFrame\n",
" | \n",
" | Notes\n",
" | -----\n",
" | The dtype will be a lower-common-denominator dtype (implicit\n",
" | upcasting); that is to say if the dtypes (even of numeric types)\n",
" | are mixed, the one that accommodates all will be chosen. Use this\n",
" | with care if you are not dealing with the blocks.\n",
" | \n",
" | e.g. If the dtypes are float16 and float32, dtype will be upcast to\n",
" | float32. If dtypes are int32 and uint8, dtype will be upcast to\n",
" | int32. By numpy.find_common_type convention, mixing int64 and uint64\n",
" | will result in a flot64 dtype.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data and other attributes inherited from pandas.core.generic.NDFrame:\n",
" | \n",
" | is_copy = None\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.base.PandasObject:\n",
" | \n",
" | __sizeof__(self)\n",
" | Generates the total memory usage for a object that returns\n",
" | either a value or Series of values\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.base.StringMixin:\n",
" | \n",
" | __bytes__(self)\n",
" | Return a string representation for a particular object.\n",
" | \n",
" | Invoked by bytes(obj) in py3 only.\n",
" | Yields a bytestring in both py2/py3.\n",
" | \n",
" | __repr__(self)\n",
" | Return a string representation for a particular object.\n",
" | \n",
" | Yields Bytestring in Py2, Unicode String in py3.\n",
" | \n",
" | __str__(self)\n",
" | Return a string representation for a particular Object\n",
" | \n",
" | Invoked by str(df) in both py2/py3.\n",
" | Yields Bytestring in Py2, Unicode String in py3.\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from pandas.core.base.StringMixin:\n",
" | \n",
" | __dict__\n",
" | dictionary for instance variables (if defined)\n",
" | \n",
" | __weakref__\n",
" | list of weak references to the object (if defined)\n",
" | \n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from pandas.core.accessor.DirNamesMixin:\n",
" | \n",
" | __dir__(self)\n",
" | Provide method name lookup and completion\n",
" | Only provide 'public' methods\n",
"\n"
]
}
],
"source": [
"help(iris)"
]
},
{
"cell_type": "code",
"execution_count": 184,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.704794Z",
"start_time": "2019-04-29T13:16:53.699549Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Junior 6\n",
"Senior 5\n",
"Name: status, dtype: int64"
]
},
"execution_count": 184,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#计算每列不同元素的数量\n",
"coun=iris['status'].value_counts()\n",
"coun"
]
},
{
"cell_type": "code",
"execution_count": 185,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.716687Z",
"start_time": "2019-04-29T13:16:53.706388Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Junior 0.545455\n",
"Senior 0.454545\n",
"Name: status, dtype: float64"
]
},
"execution_count": 185,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#计算概率\n",
"rat=coun/sum(coun)\n",
"rat"
]
},
{
"cell_type": "code",
"execution_count": 186,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.728782Z",
"start_time": "2019-04-29T13:16:53.718418Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['department', 'status', 'age', 'salary'], dtype='object')"
]
},
"execution_count": 186,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#存储列索引\n",
"spec=iris.columns\n",
"spec"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 将以上两者合成形成p(x） px函数"
]
},
{
"cell_type": "markdown",
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T11:01:39.448922Z",
"start_time": "2019-04-29T11:01:39.439837Z"
}
},
"source": [
"#### 计算p(column1|column2)\n"
]
},
{
"cell_type": "code",
"execution_count": 187,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.754313Z",
"start_time": "2019-04-29T13:16:53.731136Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" department status age salary\n",
"1 Sales Junior 2630 26K30K\n",
"2 Sales Junior 3135 31K35K\n",
"3 Systems Junior 2125 46K50K\n",
"5 Systems Junior 2630 46K50K\n",
"8 Marketing Junior 3135 41K45K\n",
"10 Secretary Junior 2630 26K30K\n",
"Junior 1.0\n",
"Name: status, dtype: float64 @@@@@@@ status\n",
" department status age salary\n",
"0 Sales Senior 3135 46K50K\n",
"4 Systems Senior 3135 66K70K\n",
"6 Systems Senior 4145 66K70K\n",
"7 Marketing Senior 3640 46K50K\n",
"9 Secretary Senior 4650 36K40K\n",
"Senior 1.0\n",
"Name: status, dtype: float64 @@@@@@@ status\n"
]
}
],
"source": [
"D='status'\n",
"daframe=iris\n",
"for i in range(len(iris[D].value_counts())):\n",
" #为dataframe中D的每一个取值拆分出叫做temp的，包含该取值的dataframe\n",
" temp=daframe[daframe[D]==coun.index[i]]\n",
" print(temp)\n",
" print(ent(temp,D),'@@@@@@@',D)\n",
" #print(ent(temp,D))\n",
" #print(gain)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### 这样我们得到了基于status分块的矩阵，接下来是分别调用px函数完成p(x|c)"
]
},
{
"cell_type": "code",
"execution_count": 188,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.765040Z",
"start_time": "2019-04-29T13:16:53.756167Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on built-in function print in module builtins:\n",
"\n",
"print(...)\n",
" print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
" \n",
" Prints the values to a stream, or to sys.stdout by default.\n",
" Optional keyword arguments:\n",
" file: a file-like object (stream); defaults to the current sys.stdout.\n",
" sep: string inserted between values, default a space.\n",
" end: string appended after the last value, default a newline.\n",
" flush: whether to forcibly flush the stream.\n",
"\n"
]
}
],
"source": [
"help(print)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 自闭调试"
]
},
{
"cell_type": "code",
"execution_count": 189,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T13:16:53.785360Z",
"start_time": "2019-04-29T13:16:53.767344Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Junior Senior\n",
"Systems 0.0 0.0\n",
"Sales 0.0 0.0\n",
"Marketing 0.0 0.0\n",
"Secretary 0.0 0.0\n",
"Junior 0.0 0.0\n",
"Senior 0.0 0.0\n",
"3135 0.0 0.0\n",
"2630 0.0 0.0\n",
"2125 0.0 0.0\n",
"4650 0.0 0.0\n",
"3640 0.0 0.0\n",
"4145 0.0 0.0\n",
"46K50K 0.0 0.0\n",
"66K70K 0.0 0.0\n",
"26K30K 0.0 0.0\n",
"31K35K 0.0 0.0\n",
"36K40K 0.0 0.0\n",
"41K45K 0.0 0.0\n",
"Index([ 'Systems', 'Sales', 'Marketing', 'Secretary', 'Junior',\n",
" 'Senior', 3135, 2630, 2125, 4650,\n",
" 3640, 4145, '46K50K', '66K70K', '26K30K',\n",
" '31K35K', '36K40K', '41K45K'],\n",
" dtype='object')\n"
]
}
],
"source": [
"D='status'\n",
"daframe=iris\n",
"indextp=[]\n",
"for j in spec:\n",
" for i in daframe[j].value_counts().index:\n",
" indextp.append(i)\n",
"frame = pd.DataFrame(np.zeros([len(indextp), len(iris[D].value_counts())]), \n",
" columns=daframe[D].value_counts().index, \n",
" index=indextp)\n",
"print(frame)\n",
"print(frame.index)"
]
},
{
"cell_type": "code",
"execution_count": 195,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T14:10:33.013469Z",
"start_time": "2019-04-29T14:10:33.008483Z"
},
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0\n"
]
},
{
"data": {
"text/plain": [
"('salary', 'Junior')"
]
},
"execution_count": 195,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"print(frame.loc['Senior','Junior'])\n",
"j,iris[D].value_counts().index[0]"
]
},
{
"cell_type": "code",
"execution_count": 196,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T14:10:39.809907Z",
"start_time": "2019-04-29T14:10:39.805754Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"Index(['46K50K', '66K70K', '26K30K', '31K35K', '36K40K', '41K45K'], dtype='object')"
]
},
"execution_count": 196,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"iris['salary'].value_counts().index"
]
},
{
"cell_type": "code",
"execution_count": 203,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T14:16:59.549545Z",
"start_time": "2019-04-29T14:16:59.347219Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Junior\n",
"Junior\n",
"Junior\n",
"Junior\n",
"Junior\n",
"Junior\n",
"Junior\n",
"error happened\n",
" 2630 0.500000\n",
"3135 0.333333\n",
"2125 0.166667\n",
"Name: age, dtype: float64 \n",
" 4650\n",
"Junior\n",
"error happened\n",
" 2630 0.500000\n",
"3135 0.333333\n",
"2125 0.166667\n",
"Name: age, dtype: float64 \n",
" 3640\n",
"Junior\n",
"error happened\n",
" 2630 0.500000\n",
"3135 0.333333\n",
"2125 0.166667\n",
"Name: age, dtype: float64 \n",
" 4145\n",
"Junior\n",
"Junior\n",
"error happened\n",
" 46K50K 0.333333\n",
"26K30K 0.333333\n",
"31K35K 0.166667\n",
"41K45K 0.166667\n",
"Name: salary, dtype: float64 \n",
" 66K70K\n",
"Junior\n",
"Junior\n",
"Junior\n",
"error happened\n",
" 46K50K 0.333333\n",
"26K30K 0.333333\n",
"31K35K 0.166667\n",
"41K45K 0.166667\n",
"Name: salary, dtype: float64 \n",
" 36K40K\n",
"Junior\n",
"Junior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"error happened\n",
" 3135 0.4\n",
"4650 0.2\n",
"4145 0.2\n",
"3640 0.2\n",
"Name: age, dtype: float64 \n",
" 2630\n",
"Senior\n",
"error happened\n",
" 3135 0.4\n",
"4650 0.2\n",
"4145 0.2\n",
"3640 0.2\n",
"Name: age, dtype: float64 \n",
" 2125\n",
"Senior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"Senior\n",
"error happened\n",
" 46K50K 0.4\n",
"66K70K 0.4\n",
"36K40K 0.2\n",
"Name: salary, dtype: float64 \n",
" 26K30K\n",
"Senior\n",
"error happened\n",
" 46K50K 0.4\n",
"66K70K 0.4\n",
"36K40K 0.2\n",
"Name: salary, dtype: float64 \n",
" 31K35K\n",
"Senior\n",
"Senior\n",
"error happened\n",
" 46K50K 0.4\n",
"66K70K 0.4\n",
"36K40K 0.2\n",
"Name: salary, dtype: float64 \n",
" 41K45K\n",
"Senior\n",
" Junior Senior\n",
"Systems 0.333333 0.4\n",
"Sales 0.333333 0.2\n",
"Marketing 0.166667 0.2\n",
"Secretary 0.166667 0.2\n",
"Junior 0.000000 0.0\n",
"Senior 0.000000 0.0\n",
"3135 0.333333 0.4\n",
"2630 0.500000 0.0\n",
"2125 0.166667 0.0\n",
"4650 0.000000 0.2\n",
"3640 0.000000 0.2\n",
"4145 0.000000 0.2\n",
"46K50K 0.333333 0.4\n",
"66K70K 0.000000 0.4\n",
"26K30K 0.333333 0.0\n",
"31K35K 0.166667 0.0\n",
"36K40K 0.000000 0.2\n",
"41K45K 0.166667 0.0\n"
]
}
],
"source": [
"D='status'\n",
"daframe=iris\n",
"indextp=[]\n",
"for j in spec:\n",
" for i in daframe[j].value_counts().index:\n",
" indextp.append(i)\n",
"frame = pd.DataFrame(np.zeros([len(indextp), len(iris[D].value_counts())]), \n",
" columns=daframe[D].value_counts().index, \n",
" index=indextp)\n",
"\n",
"\n",
"\n",
"for i in range(len(iris[D].value_counts())):\n",
" #为dataframe中D的每一个取值拆分出叫做temp的，包含该取值的dataframe\n",
" temp=daframe[daframe[D]==coun.index[i]]\n",
" for j in spec:\n",
" if j!=D:\n",
" for k in iris[j].value_counts().index:\n",
" #print('k=',k,px(temp,j))\n",
" try:\n",
" frame.loc[k,iris[D].value_counts().index[i]]=px(temp,j)[k]\n",
" except:\n",
" print('error happened\\n',px(temp,j),'\\n',k)\n",
" print(iris[D].value_counts().index[i])\n",
" #pd.Series(r)\n",
" #print(\"__________\\n\",r,\"\\np({}|{})\".format(j,iris[D].value_counts().index[i]))\n",
" #print(ent(temp,D))\n",
" #print(gain)\n",
"print(frame)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 计算p(x)"
]
},
{
"cell_type": "code",
"execution_count": 213,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T14:37:22.487391Z",
"start_time": "2019-04-29T14:37:22.478248Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Junior 0.545455\n",
"Senior 0.454545\n",
"Name: status, dtype: float64\n"
]
},
{
"data": {
"text/plain": [
"0.5454545454545454"
]
},
"execution_count": 213,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def px(daframe,colum):\n",
" \"\"\"输入dataframe以及需要计算熵的列索引，输出熵\"\"\"\n",
" coun=daframe[colum].value_counts()\n",
" rat=coun/sum(coun)\n",
" return rat\n",
"print(px(iris,'status'))\n",
"px(iris,'status')['Junior']"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 计算相对概率"
]
},
{
"cell_type": "code",
"execution_count": 212,
"metadata": {
"ExecuteTime": {
"end_time": "2019-04-29T14:35:39.113525Z",
"start_time": "2019-04-29T14:35:39.018620Z"
}
},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" Junior | \n",
" Senior | \n",
"
\n",
" \n",
" \n",
" \n",
" | Systems | \n",
" 0.333333 | \n",
" 0.4 | \n",
"
\n",
" \n",
" | Sales | \n",
" 0.333333 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | Marketing | \n",
" 0.166667 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | Secretary | \n",
" 0.166667 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | Junior | \n",
" 0.000000 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | Senior | \n",
" 0.000000 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 3135 | \n",
" 0.333333 | \n",
" 0.4 | \n",
"
\n",
" \n",
" | 2630 | \n",
" 0.500000 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 2125 | \n",
" 0.166667 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 4650 | \n",
" 0.000000 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | 3640 | \n",
" 0.000000 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | 4145 | \n",
" 0.000000 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | 46K50K | \n",
" 0.333333 | \n",
" 0.4 | \n",
"
\n",
" \n",
" | 66K70K | \n",
" 0.000000 | \n",
" 0.4 | \n",
"
\n",
" \n",
" | 26K30K | \n",
" 0.333333 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 31K35K | \n",
" 0.166667 | \n",
" 0.0 | \n",
"
\n",
" \n",
" | 36K40K | \n",
" 0.000000 | \n",
" 0.2 | \n",
"
\n",
" \n",
" | 41K45K | \n",
" 0.166667 | \n",
" 0.0 | \n",
"
\n",
" \n",
"
\n",
"