Basic Python Training at Arcesium - Day 5¶

Oct 25-31, 2018 Vikrant Patil

These notes are available online at http://notes.pipal.in/2018/arcesium-basic-oct/day5.html © Pipal Academy LLP

We will be using python 3 (>= 3.0) from anaconda for this training. You can download it from

https://www.anaconda.com/download/

Reference¶

pandas¶

Series¶

import pandas as pd
import random

s = pd.Series([random.random() for i in range(5)])

s

0    0.628380
1    0.384463
2    0.765595
3    0.340491
4    0.226506
dtype: float64

s[0]

0.62838022747381639

s[4]

0.22650626805503926

s[-1]

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-7-0e2107f91cbd> in <module>()
----> 1 s[-1]

~/usr/local/anaconda3/lib/python3.6/site-packages/pandas/core/series.py in __getitem__(self, key)
    599         key = com._apply_if_callable(key, self)
    600         try:
--> 601             result = self.index.get_value(self, key)
    602 
    603             if not is_scalar(result):

~/usr/local/anaconda3/lib/python3.6/site-packages/pandas/core/indexes/base.py in get_value(self, series, key)
   2475         try:
   2476             return self._engine.get_value(s, k,
-> 2477                                           tz=getattr(series.dtype, 'tz', None))
   2478         except KeyError as e1:
   2479             if len(self) > 0 and self.inferred_type in ['integer', 'boolean']:

pandas/_libs/index.pyx in pandas._libs.index.IndexEngine.get_value (pandas/_libs/index.c:4404)()

pandas/_libs/index.pyx in pandas._libs.index.IndexEngine.get_value (pandas/_libs/index.c:4087)()

pandas/_libs/index.pyx in pandas._libs.index.IndexEngine.get_loc (pandas/_libs/index.c:5126)()

pandas/_libs/hashtable_class_helper.pxi in pandas._libs.hashtable.Int64HashTable.get_item (pandas/_libs/hashtable.c:14031)()

pandas/_libs/hashtable_class_helper.pxi in pandas._libs.hashtable.Int64HashTable.get_item (pandas/_libs/hashtable.c:13975)()

KeyError: -1

s1 = pd.Series([11,31,43,12], index=['a','b','c','d'])

s1

a    11
b    31
c    43
d    12
dtype: int64

s

0    0.628380
1    0.384463
2    0.765595
3    0.340491
4    0.226506
dtype: float64

s1['a']

11

s1['d']

12

import string

string.ascii_lowercase

'abcdefghijklmnopqrstuvwxyz'

for c in string.ascii_lowercase[:5]:
    print(c, end=",")

a,b,c,d,e,

s2 = pd.Series([random.random()*100 for i in range(5)] , index=["alice", "alex", "elsa", "rohini", "anand"])

s2

alice     99.625605
alex       2.030569
elsa      56.333075
rohini    78.063123
anand     25.094140
dtype: float64

s3 = pd.Series([random.random()*100 for i in range(10)], index=[c for c in string.ascii_uppercase[:10]])

s3

A    61.765774
B     8.015739
C    17.649752
D    65.797848
E    18.998453
F    42.987072
G     5.766422
H    83.646609
I    57.504303
J    56.691166
dtype: float64

s3 > 50

A     True
B    False
C    False
D     True
E    False
F    False
G    False
H     True
I     True
J     True
dtype: bool

s3[s3>50]

A    61.765774
D    65.797848
H    83.646609
I    57.504303
J    56.691166
dtype: float64

s

0    0.628380
1    0.384463
2    0.765595
3    0.340491
4    0.226506
dtype: float64

cond_ = pd.Series([True, True, False, True, False])

s[cond_]

0    0.628380
1    0.384463
3    0.340491
dtype: float64

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-29-bc68999b09ce> in <module>()
----> 1 s[not cond_]

~/usr/local/anaconda3/lib/python3.6/site-packages/pandas/core/generic.py in __nonzero__(self)
    953         raise ValueError("The truth value of a {0} is ambiguous. "
    954                          "Use a.empty, a.bool(), a.item(), a.any() or a.all()."
--> 955                          .format(self.__class__.__name__))
    956 
    957     __bool__ = __nonzero__

ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().

s3 > 50

A     True
B    False
C    False
D     True
E    False
F    False
G    False
H     True
I     True
J     True
dtype: bool

s3 <= 50

A    False
B     True
C     True
D    False
E     True
F     True
G     True
H    False
I    False
J    False
dtype: bool

problem

Make a series of stock values and tiker symbol as index of size 10
Filter out all the tickers which has value >= 30

import random 
def get_data(size, value):
    return [value + random.random()*value*0.1 for i in range(size)]

d = get_data(10, 100)

d

[105.65387760526522,
 108.38141810533048,
 107.38494642691239,
 103.31749820620806,
 108.09401272471868,
 100.64431685738785,
 107.26867265702646,
 105.27026301114493,
 106.4970834801495,
 107.78678571697145]

def cond(v):
    return v>=106

[item for item in d if cond(item)]

[108.38141810533048,
 107.38494642691239,
 108.09401272471868,
 107.26867265702646,
 106.4970834801495,
 107.78678571697145]

s3

A    61.765774
B     8.015739
C    17.649752
D    65.797848
E    18.998453
F    42.987072
G     5.766422
H    83.646609
I    57.504303
J    56.691166
dtype: float64

lessthan50 = s3[s3<50]

lessthan50

B     8.015739
C    17.649752
E    18.998453
F    42.987072
G     5.766422
dtype: float64

s3[s3<50].sum()

93.4174376350916

s3[s3<50].mean()

18.683487527018322

s = pd.Series({"tata":55.5, "reliance":69.0, "infy":50.0,"xyz":100.0})

s

infy         50.0
reliance     69.0
tata         55.5
xyz         100.0
dtype: float64

s.reindex(["xyz", "reliance", "tata", "infy", "google"])

xyz         100.0
reliance     69.0
tata         55.5
infy         50.0
google        NaN
dtype: float64

s

infy         50.0
reliance     69.0
tata         55.5
xyz         100.0
dtype: float64

s1 = s.reindex(["xyz", "reliance", "tata", "infy", "google"])

s1

xyz         100.0
reliance     69.0
tata         55.5
infy         50.0
google        NaN
dtype: float64

s

infy         50.0
reliance     69.0
tata         55.5
xyz         100.0
dtype: float64

s['hello'] = 10.0

s

infy         50.0
reliance     69.0
tata         55.5
xyz         100.0
hello        10.0
dtype: float64

s1["google"] = 1000

s1

xyz          100.0
reliance      69.0
tata          55.5
infy          50.0
google      1000.0
dtype: float64

s

infy         50.0
reliance     69.0
tata         55.5
xyz         100.0
hello        10.0
dtype: float64

s.agg("sum")

284.5

s.agg("mean")

56.9

s.agg("std")

32.60828115678592

s.agg()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-61-382b553eb7a7> in <module>()
----> 1 s.agg()

TypeError: aggregate() missing 1 required positional argument: 'func'

Dataframes¶

def create_tabular_data(cols, rows):
    cols_ = [get_data(rows, 100+i*10) for i in range(cols)]
    colnames = ["col"+str(i) for i in range(cols)]
    index = [c for c in string.ascii_uppercase[:rows]]

    d = dict(zip(colnames, cols_))
    return d, index

d, index = create_tabular_data(10, 20)
df = pd.DataFrame(d, index=index)
len(cols), len(colnames), len(index)

(10, 10, 20)

pd.DataFrame({"col1":[1,2,3,4], "col2":[2,3,4,5]})

df

def create_tabular_data(cols, rows):
    cols_ = [get_data(rows, 100+i*10) for i in range(cols)]
    colnames = ["col"+str(i) for i in range(cols)]
    index = [c for c in string.ascii_uppercase[:rows]]

    d = dict(zip(colnames, cols_))
    return d, index

d, index = create_tabular_data(10, 20)
df = pd.DataFrame(d, index=index)
len(cols), len(colnames), len(index)

(10, 10, 20)

df

df.head()

df.describe()

df['col0']['A']

102.88173573840778

df [df['col0'] <= 104]

names = df.index

df['names']  = names

df

rowA = df[df.names=="A"]

df.col0

A    102.881736
B    104.643103
C    108.179150
D    106.809360
E    103.622581
F    104.936108
G    106.384699
H    100.903158
I    102.998368
J    106.381198
K    105.763294
L    104.145880
M    107.849212
N    101.402427
O    102.190091
P    103.973501
Q    100.632228
R    100.355248
S    100.234149
T    105.734044
Name: col0, dtype: float64

df

help(df.insert)

Help on method insert in module pandas.core.frame:

insert(loc, column, value, allow_duplicates=False) method of pandas.core.frame.DataFrame instance
    Insert column into DataFrame at specified location.
    
    If `allow_duplicates` is False, raises Exception if column
    is already contained in the DataFrame.
    
    Parameters
    ----------
    loc : int
        Must have 0 <= loc <= len(columns)
    column : object
    value : scalar, Series, or array-like

df.insert(0,'name_' ,names)

df

del df['names']

df

problem

Write a function which adds a new column at end which has sum of a row as value

df.col0 + df .col1

A    214.568372
B    225.182106
C    224.100074
D    221.458384
E    214.201478
F    215.582134
G    226.945379
H    220.225462
I    217.513288
J    223.539111
K    223.978393
L    223.435629
M    227.202319
N    212.923033
O    213.195607
P    216.666504
Q    212.406838
R    220.784241
S    220.925537
T    223.090490
dtype: float64

df.columns

Index(['name_', 'col0', 'col1', 'col2', 'col3', 'col4', 'col5', 'col6', 'col7',
       'col8', 'col9'],
      dtype='object')

desc = df.describe()

desc.index

Index(['count', 'mean', 'std', 'min', '25%', '50%', '75%', 'max'], dtype='object')

desc['catcol'] = desc.index

desc

countrow = desc[desc.catcol=="count"]

del countrow['catcol']

countrow

pd.concat([df, countrow])

df.shape

(20, 11)

df['categories'] = pd.Series([random.choice(["cat1", "cat2", "cat3", "cat4"]) for i in range(20)], df.index)

df

df.groupby("categories").sum()

df.groupby("categories").mean()

df.groupby("categories").std()

df['months'] = pd.Series(["from Jan", "from Feb", "Mar", "Apr"]*5, df.index)

df

m = df['months'].str.replace("from ", "")

df['months'] = m

df

help(df.groupby)

Help on method groupby in module pandas.core.generic:

groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs) method of pandas.core.frame.DataFrame instance
    Group series using mapper (dict or key function, apply given function
    to group, return result as series) or by a series of columns.
    
    Parameters
    ----------
    by : mapping, function, str, or iterable
        Used to determine the groups for the groupby.
        If ``by`` is a function, it's called on each value of the object's
        index. If a dict or Series is passed, the Series or dict VALUES
        will be used to determine the groups (the Series' values are first
        aligned; see ``.align()`` method). If an ndarray is passed, the
        values are used as-is determine the groups. A str or list of strs
        may be passed to group by the columns in ``self``
    axis : int, default 0
    level : int, level name, or sequence of such, default None
        If the axis is a MultiIndex (hierarchical), group by a particular
        level or levels
    as_index : boolean, default True
        For aggregated output, return object with group labels as the
        index. Only relevant for DataFrame input. as_index=False is
        effectively "SQL-style" grouped output
    sort : boolean, default True
        Sort group keys. Get better performance by turning this off.
        Note this does not influence the order of observations within each
        group.  groupby preserves the order of rows within each group.
    group_keys : boolean, default True
        When calling apply, add group keys to index to identify pieces
    squeeze : boolean, default False
        reduce the dimensionality of the return type if possible,
        otherwise return a consistent type
    
    Examples
    --------
    DataFrame results
    
    >>> data.groupby(func, axis=0).mean()
    >>> data.groupby(['col1', 'col2'])['col3'].mean()
    
    DataFrame with hierarchical index
    
    >>> data.groupby(['col1', 'col2']).mean()
    
    Returns
    -------
    GroupBy object

df.groupby('months')['col0'].mean()

months
Apr    104.313188
Feb    103.543617
Jan    103.596825
Mar    104.550277
Name: col0, dtype: float64

row, cols = df.shape

df.shape

(20, 13)

m = []
s = []
for i in range(cols):
    if i%2==0:
        m.append(df.groupby("months")[df.columns[i]].mean())
    else:
        s.append(df.groupby("months")[df.columns[i]].std())

---------------------------------------------------------------------------
DataError                                 Traceback (most recent call last)
<ipython-input-139-408d27f6c836> in <module>()
      3 for i in range(cols):
      4     if i%2==0:
----> 5         m.append(df.groupby("months")[df.columns[i]].mean())
      6     else:
      7         s.append(df.groupby("months")[df.columns[i]].std())

~/usr/local/anaconda3/lib/python3.6/site-packages/pandas/core/groupby.py in mean(self, *args, **kwargs)
   1035         nv.validate_groupby_func('mean', args, kwargs, ['numeric_only'])
   1036         try:
-> 1037             return self._cython_agg_general('mean', **kwargs)
   1038         except GroupByError:
   1039             raise

~/usr/local/anaconda3/lib/python3.6/site-packages/pandas/core/groupby.py in _cython_agg_general(self, how, alt, numeric_only)
    834 
    835         if len(output) == 0:
--> 836             raise DataError('No numeric types to aggregate')
    837 
    838         return self._wrap_aggregated_output(output, names)

DataError: No numeric types to aggregate

m = df['months']

help(m)

Help on Series in module pandas.core.series object:

class Series(pandas.core.base.IndexOpsMixin, pandas.core.strings.StringAccessorMixin, pandas.core.generic.NDFrame)
 |  One-dimensional ndarray with axis labels (including time series).
 |  
 |  Labels need not be unique but must be a hashable type. The object
 |  supports both integer- and label-based indexing and provides a host of
 |  methods for performing operations involving the index. Statistical
 |  methods from ndarray have been overridden to automatically exclude
 |  missing data (currently represented as NaN).
 |  
 |  Operations between Series (+, -, /, *, **) align values based on their
 |  associated index values-- they need not be the same length. The result
 |  index will be the sorted union of the two indexes.
 |  
 |  Parameters
 |  ----------
 |  data : array-like, dict, or scalar value
 |      Contains data stored in Series
 |  index : array-like or Index (1d)
 |      Values must be hashable and have the same length as `data`.
 |      Non-unique index values are allowed. Will default to
 |      RangeIndex(len(data)) if not provided. If both a dict and index
 |      sequence are used, the index will override the keys found in the
 |      dict.
 |  dtype : numpy.dtype or None
 |      If None, dtype will be inferred
 |  copy : boolean, default False
 |      Copy input data
 |  
 |  Method resolution order:
 |      Series
 |      pandas.core.base.IndexOpsMixin
 |      pandas.core.strings.StringAccessorMixin
 |      pandas.core.generic.NDFrame
 |      pandas.core.base.PandasObject
 |      pandas.core.base.StringMixin
 |      pandas.core.base.SelectionMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__ = wrapper(left, right, name='__add__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1316a8>)
 |  
 |  __and__ = wrapper(self, other)
 |  
 |  __array__(self, result=None)
 |      the array interface, return my values
 |  
 |  __array_prepare__(self, result, context=None)
 |      Gets called prior to a ufunc
 |  
 |  __array_wrap__(self, result, context=None)
 |      Gets called after a ufunc
 |  
 |  __div__ = wrapper(left, right, name='__truediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee131d90>)
 |  
 |  __divmod__ = wrapper(left, right, name='__divmod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee137048>)
 |  
 |  __eq__ = wrapper(self, other, axis=None)
 |  
 |  __float__ = wrapper(self)
 |  
 |  __floordiv__ = wrapper(left, right, name='__floordiv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee131f28>)
 |  
 |  __ge__ = wrapper(self, other, axis=None)
 |  
 |  __getitem__(self, key)
 |  
 |  __gt__ = wrapper(self, other, axis=None)
 |  
 |  __iadd__ = f(self, other)
 |  
 |  __imul__ = f(self, other)
 |  
 |  __init__(self, data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __int__ = wrapper(self)
 |  
 |  __ipow__ = f(self, other)
 |  
 |  __isub__ = f(self, other)
 |  
 |  __iter__(self)
 |      provide iteration over the values of the Series
 |      box values if necessary
 |  
 |  __itruediv__ = f(self, other)
 |  
 |  __le__ = wrapper(self, other, axis=None)
 |  
 |  __len__(self)
 |      return the length of the Series
 |  
 |  __long__ = wrapper(self)
 |  
 |  __lt__ = wrapper(self, other, axis=None)
 |  
 |  __mod__ = wrapper(left, right, name='__mod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee133158>)
 |  
 |  __mul__ = wrapper(left, right, name='__mul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee131bf8>)
 |  
 |  __ne__ = wrapper(self, other, axis=None)
 |  
 |  __or__ = wrapper(self, other)
 |  
 |  __pow__ = wrapper(left, right, name='__pow__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1332f0>)
 |  
 |  __radd__ = wrapper(left, right, name='__radd__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1318c8>)
 |  
 |  __rand__ = wrapper(self, other)
 |  
 |  __rdiv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1338c8>)
 |  
 |  __rfloordiv__ = wrapper(left, right, name='__rfloordiv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee133ae8>)
 |  
 |  __rmod__ = wrapper(left, right, name='__rmod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee133f28>)
 |  
 |  __rmul__ = wrapper(left, right, name='__rmul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee133488>)
 |  
 |  __ror__ = wrapper(self, other)
 |  
 |  __rpow__ = wrapper(left, right, name='__rpow__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee133d08>)
 |  
 |  __rsub__ = wrapper(left, right, name='__rsub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1336a8>)
 |  
 |  __rtruediv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee1338c8>)
 |  
 |  __rxor__ = wrapper(self, other)
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__ = wrapper(left, right, name='__sub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee131a60>)
 |  
 |  __truediv__ = wrapper(left, right, name='__truediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x7fbeee131d90>)
 |  
 |  __unicode__(self)
 |      Return a string representation for a particular DataFrame
 |      
 |      Invoked by unicode(df) in py2 only. Yields a Unicode String in both
 |      py2/py3.
 |  
 |  __xor__ = wrapper(self, other)
 |  
 |  add(self, other, level=None, fill_value=None, axis=0)
 |      Addition of series and other, element-wise (binary operator `add`).
 |      
 |      Equivalent to ``series + other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.radd
 |  
 |  agg = aggregate(self, func, axis=0, *args, **kwargs)
 |  
 |  aggregate(self, func, axis=0, *args, **kwargs)
 |      Aggregate using callable, string, dict, or list of string/callables
 |      
 |      .. versionadded:: 0.20.0
 |      
 |      Parameters
 |      ----------
 |      func : callable, string, dictionary, or list of string/callables
 |          Function to use for aggregating the data. If a function, must either
 |          work when passed a Series or when passed to Series.apply. For
 |          a DataFrame, can pass a dict, if the keys are DataFrame column names.
 |      
 |          Accepted Combinations are:
 |      
 |          - string function name
 |          - function
 |          - list of functions
 |          - dict of column names -> functions (or list of functions)
 |      
 |      Notes
 |      -----
 |      Numpy functions mean/median/prod/sum/std/var are special cased so the
 |      default behavior is applying the function along axis=0
 |      (e.g., np.mean(arr_2d, axis=0)) as opposed to
 |      mimicking the default Numpy behavior (e.g., np.mean(arr_2d)).
 |      
 |      agg is an alias for aggregate. Use it.
 |      
 |      Returns
 |      -------
 |      aggregated : Series
 |      
 |      Examples
 |      --------
 |      
 |      >>> s = Series(np.random.randn(10))
 |      
 |      >>> s.agg('min')
 |      -1.3018049988556679
 |      
 |      >>> s.agg(['min', 'max'])
 |      min   -1.301805
 |      max    1.127688
 |      dtype: float64
 |      
 |      See also
 |      --------
 |      pandas.Series.apply
 |      pandas.Series.transform
 |  
 |  align(self, other, join='outer', axis=None, level=None, copy=True, fill_value=None, method=None, limit=None, fill_axis=0, broadcast_axis=None)
 |      Align two object on their axes with the
 |      specified join method for each axis Index
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame or Series
 |      join : {'outer', 'inner', 'left', 'right'}, default 'outer'
 |      axis : allowed axis of the other object, default None
 |          Align on index (0), columns (1), or both (None)
 |      level : int or level name, default None
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      copy : boolean, default True
 |          Always returns new objects. If copy=False and no reindexing is
 |          required then original objects are returned.
 |      fill_value : scalar, default np.NaN
 |          Value to use for missing values. Defaults to NaN, but can be any
 |          "compatible" value
 |      method : str, default None
 |      limit : int, default None
 |      fill_axis : {0, 'index'}, default 0
 |          Filling axis, method and limit
 |      broadcast_axis : {0, 'index'}, default None
 |          Broadcast values along this axis, if aligning two objects of
 |          different dimensions
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Returns
 |      -------
 |      (left, right) : (Series, type of other)
 |          Aligned objects
 |  
 |  all(self, axis=None, bool_only=None, skipna=None, level=None, **kwargs)
 |      Return whether all elements are True over requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      bool_only : boolean, default None
 |          Include only boolean columns. If None, will attempt to use everything,
 |          then use only boolean data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      all : scalar or Series (if level specified)
 |  
 |  any(self, axis=None, bool_only=None, skipna=None, level=None, **kwargs)
 |      Return whether any element is True over requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      bool_only : boolean, default None
 |          Include only boolean columns. If None, will attempt to use everything,
 |          then use only boolean data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      any : scalar or Series (if level specified)
 |  
 |  append(self, to_append, ignore_index=False, verify_integrity=False)
 |      Concatenate two or more Series.
 |      
 |      Parameters
 |      ----------
 |      to_append : Series or list/tuple of Series
 |      ignore_index : boolean, default False
 |          If True, do not use the index labels.
 |      
 |          .. versionadded: 0.19.0
 |      
 |      verify_integrity : boolean, default False
 |          If True, raise Exception on creating index with duplicates
 |      
 |      Returns
 |      -------
 |      appended : Series
 |      
 |      Examples
 |      --------
 |      >>> s1 = pd.Series([1, 2, 3])
 |      >>> s2 = pd.Series([4, 5, 6])
 |      >>> s3 = pd.Series([4, 5, 6], index=[3,4,5])
 |      >>> s1.append(s2)
 |      0    1
 |      1    2
 |      2    3
 |      0    4
 |      1    5
 |      2    6
 |      dtype: int64
 |      
 |      >>> s1.append(s3)
 |      0    1
 |      1    2
 |      2    3
 |      3    4
 |      4    5
 |      5    6
 |      dtype: int64
 |      
 |      With `ignore_index` set to True:
 |      
 |      >>> s1.append(s2, ignore_index=True)
 |      0    1
 |      1    2
 |      2    3
 |      3    4
 |      4    5
 |      5    6
 |      dtype: int64
 |      
 |      With `verify_integrity` set to True:
 |      
 |      >>> s1.append(s2, verify_integrity=True)
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: Indexes have overlapping values: [0, 1, 2]
 |  
 |  apply(self, func, convert_dtype=True, args=(), **kwds)
 |      Invoke function on values of Series. Can be ufunc (a NumPy function
 |      that applies to the entire Series) or a Python function that only works
 |      on single values
 |      
 |      Parameters
 |      ----------
 |      func : function
 |      convert_dtype : boolean, default True
 |          Try to find better dtype for elementwise function results. If
 |          False, leave as dtype=object
 |      args : tuple
 |          Positional arguments to pass to function in addition to the value
 |      Additional keyword arguments will be passed as keywords to the function
 |      
 |      Returns
 |      -------
 |      y : Series or DataFrame if func returns a Series
 |      
 |      See also
 |      --------
 |      Series.map: For element-wise operations
 |      Series.agg: only perform aggregating type operations
 |      Series.transform: only perform transformating type operations
 |      
 |      Examples
 |      --------
 |      
 |      Create a series with typical summer temperatures for each city.
 |      
 |      >>> import pandas as pd
 |      >>> import numpy as np
 |      >>> series = pd.Series([20, 21, 12], index=['London',
 |      ... 'New York','Helsinki'])
 |      >>> series
 |      London      20
 |      New York    21
 |      Helsinki    12
 |      dtype: int64
 |      
 |      Square the values by defining a function and passing it as an
 |      argument to ``apply()``.
 |      
 |      >>> def square(x):
 |      ...     return x**2
 |      >>> series.apply(square)
 |      London      400
 |      New York    441
 |      Helsinki    144
 |      dtype: int64
 |      
 |      Square the values by passing an anonymous function as an
 |      argument to ``apply()``.
 |      
 |      >>> series.apply(lambda x: x**2)
 |      London      400
 |      New York    441
 |      Helsinki    144
 |      dtype: int64
 |      
 |      Define a custom function that needs additional positional
 |      arguments and pass these additional arguments using the
 |      ``args`` keyword.
 |      
 |      >>> def subtract_custom_value(x, custom_value):
 |      ...     return x-custom_value
 |      
 |      >>> series.apply(subtract_custom_value, args=(5,))
 |      London      15
 |      New York    16
 |      Helsinki     7
 |      dtype: int64
 |      
 |      Define a custom function that takes keyword arguments
 |      and pass these arguments to ``apply``.
 |      
 |      >>> def add_custom_values(x, **kwargs):
 |      ...     for month in kwargs:
 |      ...         x+=kwargs[month]
 |      ...         return x
 |      
 |      >>> series.apply(add_custom_values, june=30, july=20, august=25)
 |      London      95
 |      New York    96
 |      Helsinki    87
 |      dtype: int64
 |      
 |      Use a function from the Numpy library.
 |      
 |      >>> series.apply(np.log)
 |      London      2.995732
 |      New York    3.044522
 |      Helsinki    2.484907
 |      dtype: float64
 |  
 |  argmax = idxmax(self, axis=None, skipna=True, *args, **kwargs)
 |  
 |  argmin = idxmin(self, axis=None, skipna=True, *args, **kwargs)
 |  
 |  argsort(self, axis=0, kind='quicksort', order=None)
 |      Overrides ndarray.argsort. Argsorts the value, omitting NA/null values,
 |      and places the result in the same locations as the non-NA values
 |      
 |      Parameters
 |      ----------
 |      axis : int (can only be zero)
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      order : ignored
 |      
 |      Returns
 |      -------
 |      argsorted : Series, with -1 indicated where nan values are present
 |      
 |      See also
 |      --------
 |      numpy.ndarray.argsort
 |  
 |  autocorr(self, lag=1)
 |      Lag-N autocorrelation
 |      
 |      Parameters
 |      ----------
 |      lag : int, default 1
 |          Number of lags to apply before performing autocorrelation.
 |      
 |      Returns
 |      -------
 |      autocorr : float
 |  
 |  between(self, left, right, inclusive=True)
 |      Return boolean Series equivalent to left <= series <= right. NA values
 |      will be treated as False
 |      
 |      Parameters
 |      ----------
 |      left : scalar
 |          Left boundary
 |      right : scalar
 |          Right boundary
 |      
 |      Returns
 |      -------
 |      is_between : Series
 |  
 |  combine(self, other, func, fill_value=nan)
 |      Perform elementwise binary operation on two Series using given function
 |      with optional fill value when an index is missing from one Series or
 |      the other
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      func : function
 |      fill_value : scalar value
 |      
 |      Returns
 |      -------
 |      result : Series
 |  
 |  combine_first(self, other)
 |      Combine Series values, choosing the calling Series's values
 |      first. Result index will be the union of the two indexes
 |      
 |      Parameters
 |      ----------
 |      other : Series
 |      
 |      Returns
 |      -------
 |      y : Series
 |  
 |  compound(self, axis=None, skipna=None, level=None)
 |      Return the compound percentage of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      compounded : scalar or Series (if level specified)
 |  
 |  compress(self, condition, *args, **kwargs)
 |      Return selected slices of an array along given axis as a Series
 |      
 |      See also
 |      --------
 |      numpy.ndarray.compress
 |  
 |  corr(self, other, method='pearson', min_periods=None)
 |      Compute correlation with `other` Series, excluding missing values
 |      
 |      Parameters
 |      ----------
 |      other : Series
 |      method : {'pearson', 'kendall', 'spearman'}
 |          * pearson : standard correlation coefficient
 |          * kendall : Kendall Tau correlation coefficient
 |          * spearman : Spearman rank correlation
 |      min_periods : int, optional
 |          Minimum number of observations needed to have a valid result
 |      
 |      
 |      Returns
 |      -------
 |      correlation : float
 |  
 |  count(self, level=None)
 |      Return number of non-NA/null observations in the Series
 |      
 |      Parameters
 |      ----------
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a smaller Series
 |      
 |      Returns
 |      -------
 |      nobs : int or Series (if level specified)
 |  
 |  cov(self, other, min_periods=None)
 |      Compute covariance with Series, excluding missing values
 |      
 |      Parameters
 |      ----------
 |      other : Series
 |      min_periods : int, optional
 |          Minimum number of observations needed to have a valid result
 |      
 |      Returns
 |      -------
 |      covariance : float
 |      
 |      Normalized by N-1 (unbiased estimator).
 |  
 |  cummax(self, axis=None, skipna=True, *args, **kwargs)
 |      Return cumulative max over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      cummax : scalar
 |      
 |      
 |      
 |      See also
 |      --------
 |      pandas.core.window.Expanding.max : Similar functionality
 |          but ignores ``NaN`` values.
 |  
 |  cummin(self, axis=None, skipna=True, *args, **kwargs)
 |      Return cumulative minimum over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      cummin : scalar
 |      
 |      
 |      
 |      See also
 |      --------
 |      pandas.core.window.Expanding.min : Similar functionality
 |          but ignores ``NaN`` values.
 |  
 |  cumprod(self, axis=None, skipna=True, *args, **kwargs)
 |      Return cumulative product over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      cumprod : scalar
 |      
 |      
 |      
 |      See also
 |      --------
 |      pandas.core.window.Expanding.prod : Similar functionality
 |          but ignores ``NaN`` values.
 |  
 |  cumsum(self, axis=None, skipna=True, *args, **kwargs)
 |      Return cumulative sum over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      cumsum : scalar
 |      
 |      
 |      
 |      See also
 |      --------
 |      pandas.core.window.Expanding.sum : Similar functionality
 |          but ignores ``NaN`` values.
 |  
 |  diff(self, periods=1)
 |      1st discrete difference of object
 |      
 |      Parameters
 |      ----------
 |      periods : int, default 1
 |          Periods to shift for forming difference
 |      
 |      Returns
 |      -------
 |      diffed : Series
 |  
 |  div = truediv(self, other, level=None, fill_value=None, axis=0)
 |  
 |  divide = truediv(self, other, level=None, fill_value=None, axis=0)
 |  
 |  dot(self, other)
 |      Matrix multiplication with DataFrame or inner-product with Series
 |      objects
 |      
 |      Parameters
 |      ----------
 |      other : Series or DataFrame
 |      
 |      Returns
 |      -------
 |      dot_product : scalar or Series
 |  
 |  drop_duplicates(self, keep='first', inplace=False)
 |      Return Series with duplicate values removed
 |      
 |      Parameters
 |      ----------
 |      
 |      keep : {'first', 'last', False}, default 'first'
 |          - ``first`` : Drop duplicates except for the first occurrence.
 |          - ``last`` : Drop duplicates except for the last occurrence.
 |          - False : Drop all duplicates.
 |      inplace : boolean, default False
 |      If True, performs operation inplace and returns None.
 |      
 |      Returns
 |      -------
 |      deduplicated : Series
 |  
 |  dropna(self, axis=0, inplace=False, **kwargs)
 |      Return Series without null values
 |      
 |      Returns
 |      -------
 |      valid : Series
 |      inplace : boolean, default False
 |          Do operation in place.
 |  
 |  duplicated(self, keep='first')
 |      Return boolean Series denoting duplicate values
 |      
 |      Parameters
 |      ----------
 |      keep : {'first', 'last', False}, default 'first'
 |          - ``first`` : Mark duplicates as ``True`` except for the first
 |            occurrence.
 |          - ``last`` : Mark duplicates as ``True`` except for the last
 |            occurrence.
 |          - False : Mark all duplicates as ``True``.
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq(self, other, level=None, fill_value=None, axis=0)
 |      Equal to of series and other, element-wise (binary operator `eq`).
 |      
 |      Equivalent to ``series == other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  ewm(self, com=None, span=None, halflife=None, alpha=None, min_periods=0, freq=None, adjust=True, ignore_na=False, axis=0)
 |      Provides exponential weighted functions
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      com : float, optional
 |          Specify decay in terms of center of mass,
 |          :math:`\alpha = 1 / (1 + com),\text{ for } com \geq 0`
 |      span : float, optional
 |          Specify decay in terms of span,
 |          :math:`\alpha = 2 / (span + 1),\text{ for } span \geq 1`
 |      halflife : float, optional
 |          Specify decay in terms of half-life,
 |          :math:`\alpha = 1 - exp(log(0.5) / halflife),\text{ for } halflife > 0`
 |      alpha : float, optional
 |          Specify smoothing factor :math:`\alpha` directly,
 |          :math:`0 < \alpha \leq 1`
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      min_periods : int, default 0
 |          Minimum number of observations in window required to have a value
 |          (otherwise result is NA).
 |      freq : None or string alias / date offset object, default=None (DEPRECATED)
 |          Frequency to conform to before computing statistic
 |      adjust : boolean, default True
 |          Divide by decaying adjustment factor in beginning periods to account
 |          for imbalance in relative weightings (viewing EWMA as a moving average)
 |      ignore_na : boolean, default False
 |          Ignore missing values when calculating weights;
 |          specify True to reproduce pre-0.15.0 behavior
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = DataFrame({'B': [0, 1, 2, np.nan, 4]})
 |           B
 |      0  0.0
 |      1  1.0
 |      2  2.0
 |      3  NaN
 |      4  4.0
 |      
 |      >>> df.ewm(com=0.5).mean()
 |                B
 |      0  0.000000
 |      1  0.750000
 |      2  1.615385
 |      3  1.615385
 |      4  3.670213
 |      
 |      Notes
 |      -----
 |      Exactly one of center of mass, span, half-life, and alpha must be provided.
 |      Allowed values and relationship between the parameters are specified in the
 |      parameter descriptions above; see the link at the end of this section for
 |      a detailed explanation.
 |      
 |      The `freq` keyword is used to conform time series data to a specified
 |      frequency by resampling the data. This is done with the default parameters
 |      of :meth:`~pandas.Series.resample` (i.e. using the `mean`).
 |      
 |      When adjust is True (default), weighted averages are calculated using
 |      weights (1-alpha)**(n-1), (1-alpha)**(n-2), ..., 1-alpha, 1.
 |      
 |      When adjust is False, weighted averages are calculated recursively as:
 |         weighted_average[0] = arg[0];
 |         weighted_average[i] = (1-alpha)*weighted_average[i-1] + alpha*arg[i].
 |      
 |      When ignore_na is False (default), weights are based on absolute positions.
 |      For example, the weights of x and y used in calculating the final weighted
 |      average of [x, None, y] are (1-alpha)**2 and 1 (if adjust is True), and
 |      (1-alpha)**2 and alpha (if adjust is False).
 |      
 |      When ignore_na is True (reproducing pre-0.15.0 behavior), weights are based
 |      on relative positions. For example, the weights of x and y used in
 |      calculating the final weighted average of [x, None, y] are 1-alpha and 1
 |      (if adjust is True), and 1-alpha and alpha (if adjust is False).
 |      
 |      More details can be found at
 |      http://pandas.pydata.org/pandas-docs/stable/computation.html#exponentially-weighted-windows
 |  
 |  expanding(self, min_periods=1, freq=None, center=False, axis=0)
 |      Provides expanding transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      min_periods : int, default None
 |          Minimum number of observations in window required to have a value
 |          (otherwise result is NA).
 |      freq : string or DateOffset object, optional (default None) (DEPRECATED)
 |          Frequency to conform the data to before computing the statistic.
 |          Specified as a frequency string or DateOffset object.
 |      center : boolean, default False
 |          Set the labels at the center of the window.
 |      axis : int or string, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = DataFrame({'B': [0, 1, 2, np.nan, 4]})
 |           B
 |      0  0.0
 |      1  1.0
 |      2  2.0
 |      3  NaN
 |      4  4.0
 |      
 |      >>> df.expanding(2).sum()
 |           B
 |      0  NaN
 |      1  1.0
 |      2  3.0
 |      3  3.0
 |      4  7.0
 |      
 |      Notes
 |      -----
 |      By default, the result is set to the right edge of the window. This can be
 |      changed to the center of the window by setting ``center=True``.
 |      
 |      The `freq` keyword is used to conform time series data to a specified
 |      frequency by resampling the data. This is done with the default parameters
 |      of :meth:`~pandas.Series.resample` (i.e. using the `mean`).
 |  
 |  fillna(self, value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
 |      Fill NA/NaN values using the specified method
 |      
 |      Parameters
 |      ----------
 |      value : scalar, dict, Series, or DataFrame
 |          Value to use to fill holes (e.g. 0), alternately a
 |          dict/Series/DataFrame of values specifying which value to use for
 |          each index (for a Series) or column (for a DataFrame). (values not
 |          in the dict/Series/DataFrame will not be filled). This value cannot
 |          be a list.
 |      method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
 |          Method to use for filling holes in reindexed Series
 |          pad / ffill: propagate last valid observation forward to next valid
 |          backfill / bfill: use NEXT valid observation to fill gap
 |      axis : {0, 'index'}
 |      inplace : boolean, default False
 |          If True, fill in place. Note: this will modify any
 |          other views on this object, (e.g. a no-copy slice for a column in a
 |          DataFrame).
 |      limit : int, default None
 |          If method is specified, this is the maximum number of consecutive
 |          NaN values to forward/backward fill. In other words, if there is
 |          a gap with more than this number of consecutive NaNs, it will only
 |          be partially filled. If method is not specified, this is the
 |          maximum number of entries along the entire axis where NaNs will be
 |          filled. Must be greater than 0 if not None.
 |      downcast : dict, default is None
 |          a dict of item->dtype of what to downcast if possible,
 |          or the string 'infer' which will try to downcast to an appropriate
 |          equal type (e.g. float64 to int64 if possible)
 |      
 |      See Also
 |      --------
 |      reindex, asfreq
 |      
 |      Returns
 |      -------
 |      filled : Series
 |  
 |  first_valid_index(self)
 |      Return label for first non-NA/null value
 |  
 |  floordiv(self, other, level=None, fill_value=None, axis=0)
 |      Integer division of series and other, element-wise (binary operator `floordiv`).
 |      
 |      Equivalent to ``series // other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rfloordiv
 |  
 |  ge(self, other, level=None, fill_value=None, axis=0)
 |      Greater than or equal to of series and other, element-wise (binary operator `ge`).
 |      
 |      Equivalent to ``series >= other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  get_value(self, label, takeable=False)
 |      Quickly retrieve single value at passed index label
 |      
 |      Parameters
 |      ----------
 |      index : label
 |      takeable : interpret the index as indexers, default False
 |      
 |      Returns
 |      -------
 |      value : scalar value
 |  
 |  get_values(self)
 |      same as values (but handles sparseness conversions); is a view
 |  
 |  gt(self, other, level=None, fill_value=None, axis=0)
 |      Greater than of series and other, element-wise (binary operator `gt`).
 |      
 |      Equivalent to ``series > other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  hist = hist_series(self, by=None, ax=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, figsize=None, bins=10, **kwds)
 |      Draw histogram of the input series using matplotlib
 |      
 |      Parameters
 |      ----------
 |      by : object, optional
 |          If passed, then used to form histograms for separate groups
 |      ax : matplotlib axis object
 |          If not passed, uses gca()
 |      grid : boolean, default True
 |          Whether to show axis grid lines
 |      xlabelsize : int, default None
 |          If specified changes the x-axis label size
 |      xrot : float, default None
 |          rotation of x axis labels
 |      ylabelsize : int, default None
 |          If specified changes the y-axis label size
 |      yrot : float, default None
 |          rotation of y axis labels
 |      figsize : tuple, default None
 |          figure size in inches by default
 |      bins: integer, default 10
 |          Number of histogram bins to be used
 |      kwds : keywords
 |          To be passed to the actual plotting function
 |      
 |      Notes
 |      -----
 |      See matplotlib documentation online for more on this
 |  
 |  idxmax(self, axis=None, skipna=True, *args, **kwargs)
 |      Index of first occurrence of maximum of values.
 |      
 |      Parameters
 |      ----------
 |      skipna : boolean, default True
 |          Exclude NA/null values
 |      
 |      Returns
 |      -------
 |      idxmax : Index of maximum of values
 |      
 |      Notes
 |      -----
 |      This method is the Series version of ``ndarray.argmax``.
 |      
 |      See Also
 |      --------
 |      DataFrame.idxmax
 |      numpy.ndarray.argmax
 |  
 |  idxmin(self, axis=None, skipna=True, *args, **kwargs)
 |      Index of first occurrence of minimum of values.
 |      
 |      Parameters
 |      ----------
 |      skipna : boolean, default True
 |          Exclude NA/null values
 |      
 |      Returns
 |      -------
 |      idxmin : Index of minimum of values
 |      
 |      Notes
 |      -----
 |      This method is the Series version of ``ndarray.argmin``.
 |      
 |      See Also
 |      --------
 |      DataFrame.idxmin
 |      numpy.ndarray.argmin
 |  
 |  isin(self, values)
 |      Return a boolean :class:`~pandas.Series` showing whether each element
 |      in the :class:`~pandas.Series` is exactly contained in the passed
 |      sequence of ``values``.
 |      
 |      Parameters
 |      ----------
 |      values : set or list-like
 |          The sequence of values to test. Passing in a single string will
 |          raise a ``TypeError``. Instead, turn a single string into a
 |          ``list`` of one element.
 |      
 |          .. versionadded:: 0.18.1
 |      
 |          Support for values as a set
 |      
 |      Returns
 |      -------
 |      isin : Series (bool dtype)
 |      
 |      Raises
 |      ------
 |      TypeError
 |        * If ``values`` is a string
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.isin
 |      
 |      Examples
 |      --------
 |      
 |      >>> s = pd.Series(list('abc'))
 |      >>> s.isin(['a', 'c', 'e'])
 |      0     True
 |      1    False
 |      2     True
 |      dtype: bool
 |      
 |      Passing a single string as ``s.isin('a')`` will raise an error. Use
 |      a list of one element instead:
 |      
 |      >>> s.isin(['a'])
 |      0     True
 |      1    False
 |      2    False
 |      dtype: bool
 |  
 |  items = iteritems(self)
 |  
 |  iteritems(self)
 |      Lazily iterate over (index, value) tuples
 |  
 |  keys(self)
 |      Alias for index
 |  
 |  kurt(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return unbiased kurtosis over requested axis using Fisher's definition of
 |      kurtosis (kurtosis of normal == 0.0). Normalized by N-1
 |      
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      kurt : scalar or Series (if level specified)
 |  
 |  kurtosis = kurt(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |  
 |  last_valid_index(self)
 |      Return label for last non-NA/null value
 |  
 |  le(self, other, level=None, fill_value=None, axis=0)
 |      Less than or equal to of series and other, element-wise (binary operator `le`).
 |      
 |      Equivalent to ``series <= other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  lt(self, other, level=None, fill_value=None, axis=0)
 |      Less than of series and other, element-wise (binary operator `lt`).
 |      
 |      Equivalent to ``series < other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  mad(self, axis=None, skipna=None, level=None)
 |      Return the mean absolute deviation of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      mad : scalar or Series (if level specified)
 |  
 |  map(self, arg, na_action=None)
 |      Map values of Series using input correspondence (which can be
 |      a dict, Series, or function)
 |      
 |      Parameters
 |      ----------
 |      arg : function, dict, or Series
 |      na_action : {None, 'ignore'}
 |          If 'ignore', propagate NA values, without passing them to the
 |          mapping function
 |      
 |      Returns
 |      -------
 |      y : Series
 |          same index as caller
 |      
 |      Examples
 |      --------
 |      
 |      Map inputs to outputs (both of type `Series`)
 |      
 |      >>> x = pd.Series([1,2,3], index=['one', 'two', 'three'])
 |      >>> x
 |      one      1
 |      two      2
 |      three    3
 |      dtype: int64
 |      
 |      >>> y = pd.Series(['foo', 'bar', 'baz'], index=[1,2,3])
 |      >>> y
 |      1    foo
 |      2    bar
 |      3    baz
 |      
 |      >>> x.map(y)
 |      one   foo
 |      two   bar
 |      three baz
 |      
 |      If `arg` is a dictionary, return a new Series with values converted
 |      according to the dictionary's mapping:
 |      
 |      >>> z = {1: 'A', 2: 'B', 3: 'C'}
 |      
 |      >>> x.map(z)
 |      one   A
 |      two   B
 |      three C
 |      
 |      Use na_action to control whether NA values are affected by the mapping
 |      function.
 |      
 |      >>> s = pd.Series([1, 2, 3, np.nan])
 |      
 |      >>> s2 = s.map('this is a string {}'.format, na_action=None)
 |      0    this is a string 1.0
 |      1    this is a string 2.0
 |      2    this is a string 3.0
 |      3    this is a string nan
 |      dtype: object
 |      
 |      >>> s3 = s.map('this is a string {}'.format, na_action='ignore')
 |      0    this is a string 1.0
 |      1    this is a string 2.0
 |      2    this is a string 3.0
 |      3                     NaN
 |      dtype: object
 |      
 |      See Also
 |      --------
 |      Series.apply: For applying more complex functions on a Series
 |      DataFrame.apply: Apply a function row-/column-wise
 |      DataFrame.applymap: Apply a function elementwise on a whole DataFrame
 |      
 |      Notes
 |      -----
 |      When `arg` is a dictionary, values in Series that are not in the
 |      dictionary (as keys) are converted to ``NaN``. However, if the
 |      dictionary is a ``dict`` subclass that defines ``__missing__`` (i.e.
 |      provides a method for default values), then this default is used
 |      rather than ``NaN``:
 |      
 |      >>> from collections import Counter
 |      >>> counter = Counter()
 |      >>> counter['bar'] += 1
 |      >>> y.map(counter)
 |      1    0
 |      2    1
 |      3    0
 |      dtype: int64
 |  
 |  max(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      This method returns the maximum of the values in the object.
 |                  If you want the *index* of the maximum, use ``idxmax``. This is
 |                  the equivalent of the ``numpy.ndarray`` method ``argmax``.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      max : scalar or Series (if level specified)
 |  
 |  mean(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return the mean of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      mean : scalar or Series (if level specified)
 |  
 |  median(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return the median of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      median : scalar or Series (if level specified)
 |  
 |  memory_usage(self, index=True, deep=False)
 |      Memory usage of the Series
 |      
 |      Parameters
 |      ----------
 |      index : bool
 |          Specifies whether to include memory usage of Series index
 |      deep : bool
 |          Introspect the data deeply, interrogate
 |          `object` dtypes for system-level memory consumption
 |      
 |      Returns
 |      -------
 |      scalar bytes of memory consumed
 |      
 |      Notes
 |      -----
 |      Memory usage does not include memory consumed by elements that
 |      are not components of the array if deep=False
 |      
 |      See Also
 |      --------
 |      numpy.ndarray.nbytes
 |  
 |  min(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      This method returns the minimum of the values in the object.
 |                  If you want the *index* of the minimum, use ``idxmin``. This is
 |                  the equivalent of the ``numpy.ndarray`` method ``argmin``.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      min : scalar or Series (if level specified)
 |  
 |  mod(self, other, level=None, fill_value=None, axis=0)
 |      Modulo of series and other, element-wise (binary operator `mod`).
 |      
 |      Equivalent to ``series % other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rmod
 |  
 |  mode(self)
 |      Return the mode(s) of the dataset.
 |      
 |      Always returns Series even if only one value is returned.
 |      
 |      Returns
 |      -------
 |      modes : Series (sorted)
 |  
 |  mul(self, other, level=None, fill_value=None, axis=0)
 |      Multiplication of series and other, element-wise (binary operator `mul`).
 |      
 |      Equivalent to ``series * other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rmul
 |  
 |  multiply = mul(self, other, level=None, fill_value=None, axis=0)
 |  
 |  ne(self, other, level=None, fill_value=None, axis=0)
 |      Not equal to of series and other, element-wise (binary operator `ne`).
 |      
 |      Equivalent to ``series != other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.None
 |  
 |  nlargest(self, n=5, keep='first')
 |      Return the largest `n` elements.
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Return this many descending sorted values
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      top_n : Series
 |          The n largest values in the Series, in sorted order
 |      
 |      Notes
 |      -----
 |      Faster than ``.sort_values(ascending=False).head(n)`` for small `n`
 |      relative to the size of the ``Series`` object.
 |      
 |      See Also
 |      --------
 |      Series.nsmallest
 |      
 |      Examples
 |      --------
 |      >>> import pandas as pd
 |      >>> import numpy as np
 |      >>> s = pd.Series(np.random.randn(10**6))
 |      >>> s.nlargest(10)  # only sorts up to the N requested
 |      219921    4.644710
 |      82124     4.608745
 |      421689    4.564644
 |      425277    4.447014
 |      718691    4.414137
 |      43154     4.403520
 |      283187    4.313922
 |      595519    4.273635
 |      503969    4.250236
 |      121637    4.240952
 |      dtype: float64
 |  
 |  nonzero(self)
 |      Return the indices of the elements that are non-zero
 |      
 |      This method is equivalent to calling `numpy.nonzero` on the
 |      series data. For compatability with NumPy, the return value is
 |      the same (a tuple with an array of indices for each dimension),
 |      but it will always be a one-item tuple because series only have
 |      one dimension.
 |      
 |      Examples
 |      --------
 |      >>> s = pd.Series([0, 3, 0, 4])
 |      >>> s.nonzero()
 |      (array([1, 3]),)
 |      >>> s.iloc[s.nonzero()[0]]
 |      1    3
 |      3    4
 |      dtype: int64
 |      
 |      See Also
 |      --------
 |      numpy.nonzero
 |  
 |  nsmallest(self, n=5, keep='first')
 |      Return the smallest `n` elements.
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Return this many ascending sorted values
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      bottom_n : Series
 |          The n smallest values in the Series, in sorted order
 |      
 |      Notes
 |      -----
 |      Faster than ``.sort_values().head(n)`` for small `n` relative to
 |      the size of the ``Series`` object.
 |      
 |      See Also
 |      --------
 |      Series.nlargest
 |      
 |      Examples
 |      --------
 |      >>> import pandas as pd
 |      >>> import numpy as np
 |      >>> s = pd.Series(np.random.randn(10**6))
 |      >>> s.nsmallest(10)  # only sorts up to the N requested
 |      288532   -4.954580
 |      732345   -4.835960
 |      64803    -4.812550
 |      446457   -4.609998
 |      501225   -4.483945
 |      669476   -4.472935
 |      973615   -4.401699
 |      621279   -4.355126
 |      773916   -4.347355
 |      359919   -4.331927
 |      dtype: float64
 |  
 |  pow(self, other, level=None, fill_value=None, axis=0)
 |      Exponential power of series and other, element-wise (binary operator `pow`).
 |      
 |      Equivalent to ``series ** other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rpow
 |  
 |  prod(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return the product of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      prod : scalar or Series (if level specified)
 |  
 |  product = prod(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |  
 |  ptp(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Returns the difference between the maximum value and the
 |                  minimum value in the object. This is the equivalent of the
 |                  ``numpy.ndarray`` method ``ptp``.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      ptp : scalar or Series (if level specified)
 |  
 |  put(self, *args, **kwargs)
 |      Applies the `put` method to its `values` attribute
 |      if it has one.
 |      
 |      See also
 |      --------
 |      numpy.ndarray.put
 |  
 |  quantile(self, q=0.5, interpolation='linear')
 |      Return value at the given quantile, a la numpy.percentile.
 |      
 |      Parameters
 |      ----------
 |      q : float or array-like, default 0.5 (50% quantile)
 |          0 <= q <= 1, the quantile(s) to compute
 |      interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
 |          .. versionadded:: 0.18.0
 |      
 |          This optional parameter specifies the interpolation method to use,
 |          when the desired quantile lies between two data points `i` and `j`:
 |      
 |              * linear: `i + (j - i) * fraction`, where `fraction` is the
 |                fractional part of the index surrounded by `i` and `j`.
 |              * lower: `i`.
 |              * higher: `j`.
 |              * nearest: `i` or `j` whichever is nearest.
 |              * midpoint: (`i` + `j`) / 2.
 |      
 |      Returns
 |      -------
 |      quantile : float or Series
 |          if ``q`` is an array, a Series will be returned where the
 |          index is ``q`` and the values are the quantiles.
 |      
 |      Examples
 |      --------
 |      >>> s = Series([1, 2, 3, 4])
 |      >>> s.quantile(.5)
 |      2.5
 |      >>> s.quantile([.25, .5, .75])
 |      0.25    1.75
 |      0.50    2.50
 |      0.75    3.25
 |      dtype: float64
 |  
 |  radd(self, other, level=None, fill_value=None, axis=0)
 |      Addition of series and other, element-wise (binary operator `radd`).
 |      
 |      Equivalent to ``other + series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.add
 |  
 |  ravel(self, order='C')
 |      Return the flattened underlying data as an ndarray
 |      
 |      See also
 |      --------
 |      numpy.ndarray.ravel
 |  
 |  rdiv = rtruediv(self, other, level=None, fill_value=None, axis=0)
 |  
 |  reindex(self, index=None, **kwargs)
 |      Conform Series to new index with optional filling logic, placing
 |      NA/NaN in locations having no value in the previous index. A new object
 |      is produced unless the new index is equivalent to the current one and
 |      copy=False
 |      
 |      Parameters
 |      ----------
 |      index : array-like, optional (can be specified in order, or as
 |          keywords)
 |          New labels / index to conform to. Preferably an Index object to
 |          avoid duplicating data
 |      method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}, optional
 |          method to use for filling holes in reindexed DataFrame.
 |          Please note: this is only  applicable to DataFrames/Series with a
 |          monotonically increasing/decreasing index.
 |      
 |          * default: don't fill gaps
 |          * pad / ffill: propagate last valid observation forward to next
 |            valid
 |          * backfill / bfill: use next valid observation to fill gap
 |          * nearest: use nearest valid observations to fill gap
 |      
 |      copy : boolean, default True
 |          Return a new object, even if the passed indexes are the same
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      fill_value : scalar, default np.NaN
 |          Value to use for missing values. Defaults to NaN, but can be any
 |          "compatible" value
 |      limit : int, default None
 |          Maximum number of consecutive elements to forward or backward fill
 |      tolerance : optional
 |          Maximum distance between original and new labels for inexact
 |          matches. The values of the index at the matching locations most
 |          satisfy the equation ``abs(index[indexer] - target) <= tolerance``.
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Examples
 |      --------
 |      
 |      Create a dataframe with some fictional data.
 |      
 |      >>> index = ['Firefox', 'Chrome', 'Safari', 'IE10', 'Konqueror']
 |      >>> df = pd.DataFrame({
 |      ...      'http_status': [200,200,404,404,301],
 |      ...      'response_time': [0.04, 0.02, 0.07, 0.08, 1.0]},
 |      ...       index=index)
 |      >>> df
 |                 http_status  response_time
 |      Firefox            200           0.04
 |      Chrome             200           0.02
 |      Safari             404           0.07
 |      IE10               404           0.08
 |      Konqueror          301           1.00
 |      
 |      Create a new index and reindex the dataframe. By default
 |      values in the new index that do not have corresponding
 |      records in the dataframe are assigned ``NaN``.
 |      
 |      >>> new_index= ['Safari', 'Iceweasel', 'Comodo Dragon', 'IE10',
 |      ...             'Chrome']
 |      >>> df.reindex(new_index)
 |                     http_status  response_time
 |      Safari               404.0           0.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                 404.0           0.08
 |      Chrome               200.0           0.02
 |      
 |      We can fill in the missing values by passing a value to
 |      the keyword ``fill_value``. Because the index is not monotonically
 |      increasing or decreasing, we cannot use arguments to the keyword
 |      ``method`` to fill the ``NaN`` values.
 |      
 |      >>> df.reindex(new_index, fill_value=0)
 |                     http_status  response_time
 |      Safari                 404           0.07
 |      Iceweasel                0           0.00
 |      Comodo Dragon            0           0.00
 |      IE10                   404           0.08
 |      Chrome                 200           0.02
 |      
 |      >>> df.reindex(new_index, fill_value='missing')
 |                    http_status response_time
 |      Safari                404          0.07
 |      Iceweasel         missing       missing
 |      Comodo Dragon     missing       missing
 |      IE10                  404          0.08
 |      Chrome                200          0.02
 |      
 |      To further illustrate the filling functionality in
 |      ``reindex``, we will create a dataframe with a
 |      monotonically increasing index (for example, a sequence
 |      of dates).
 |      
 |      >>> date_index = pd.date_range('1/1/2010', periods=6, freq='D')
 |      >>> df2 = pd.DataFrame({"prices": [100, 101, np.nan, 100, 89, 88]},
 |      ...                    index=date_index)
 |      >>> df2
 |                  prices
 |      2010-01-01     100
 |      2010-01-02     101
 |      2010-01-03     NaN
 |      2010-01-04     100
 |      2010-01-05      89
 |      2010-01-06      88
 |      
 |      Suppose we decide to expand the dataframe to cover a wider
 |      date range.
 |      
 |      >>> date_index2 = pd.date_range('12/29/2009', periods=10, freq='D')
 |      >>> df2.reindex(date_index2)
 |                  prices
 |      2009-12-29     NaN
 |      2009-12-30     NaN
 |      2009-12-31     NaN
 |      2010-01-01     100
 |      2010-01-02     101
 |      2010-01-03     NaN
 |      2010-01-04     100
 |      2010-01-05      89
 |      2010-01-06      88
 |      2010-01-07     NaN
 |      
 |      The index entries that did not have a value in the original data frame
 |      (for example, '2009-12-29') are by default filled with ``NaN``.
 |      If desired, we can fill in the missing values using one of several
 |      options.
 |      
 |      For example, to backpropagate the last valid value to fill the ``NaN``
 |      values, pass ``bfill`` as an argument to the ``method`` keyword.
 |      
 |      >>> df2.reindex(date_index2, method='bfill')
 |                  prices
 |      2009-12-29     100
 |      2009-12-30     100
 |      2009-12-31     100
 |      2010-01-01     100
 |      2010-01-02     101
 |      2010-01-03     NaN
 |      2010-01-04     100
 |      2010-01-05      89
 |      2010-01-06      88
 |      2010-01-07     NaN
 |      
 |      Please note that the ``NaN`` value present in the original dataframe
 |      (at index value 2010-01-03) will not be filled by any of the
 |      value propagation schemes. This is because filling while reindexing
 |      does not look at dataframe values, but only compares the original and
 |      desired indexes. If you do want to fill in the ``NaN`` values present
 |      in the original dataframe, use the ``fillna()`` method.
 |      
 |      Returns
 |      -------
 |      reindexed : Series
 |  
 |  reindex_axis(self, labels, axis=0, **kwargs)
 |      for compatibility with higher dims
 |  
 |  rename(self, index=None, **kwargs)
 |      Alter axes input function or functions. Function / dict values must be
 |      unique (1-to-1). Labels not contained in a dict / Series will be left
 |      as-is. Extra labels listed don't throw an error. Alternatively, change
 |      ``Series.name`` with a scalar value (Series only).
 |      
 |      Parameters
 |      ----------
 |      index : scalar, list-like, dict-like or function, optional
 |          Scalar or list-like will alter the ``Series.name`` attribute,
 |          and raise on DataFrame or Panel.
 |          dict-like or functions are transformations to apply to
 |          that axis' values
 |      copy : boolean, default True
 |          Also copy underlying data
 |      inplace : boolean, default False
 |          Whether to return a new Series. If True then value of copy is
 |          ignored.
 |      level : int or level name, default None
 |          In case of a MultiIndex, only rename labels in the specified
 |          level.
 |      
 |      Returns
 |      -------
 |      renamed : Series (new object)
 |      
 |      See Also
 |      --------
 |      pandas.NDFrame.rename_axis
 |      
 |      Examples
 |      --------
 |      >>> s = pd.Series([1, 2, 3])
 |      >>> s
 |      0    1
 |      1    2
 |      2    3
 |      dtype: int64
 |      >>> s.rename("my_name") # scalar, changes Series.name
 |      0    1
 |      1    2
 |      2    3
 |      Name: my_name, dtype: int64
 |      >>> s.rename(lambda x: x ** 2)  # function, changes labels
 |      0    1
 |      1    2
 |      4    3
 |      dtype: int64
 |      >>> s.rename({1: 3, 2: 5})  # mapping, changes labels
 |      0    1
 |      3    2
 |      5    3
 |      dtype: int64
 |      >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
 |      >>> df.rename(2)
 |      Traceback (most recent call last):
 |      ...
 |      TypeError: 'int' object is not callable
 |      >>> df.rename(index=str, columns={"A": "a", "B": "c"})
 |         a  c
 |      0  1  4
 |      1  2  5
 |      2  3  6
 |      >>> df.rename(index=str, columns={"A": "a", "C": "c"})
 |         a  B
 |      0  1  4
 |      1  2  5
 |      2  3  6
 |  
 |  reorder_levels(self, order)
 |      Rearrange index levels using input order. May not drop or duplicate
 |      levels
 |      
 |      Parameters
 |      ----------
 |      order : list of int representing new level order.
 |             (reference level by number or key)
 |      axis : where to reorder levels
 |      
 |      Returns
 |      -------
 |      type of caller (new object)
 |  
 |  repeat(self, repeats, *args, **kwargs)
 |      Repeat elements of an Series. Refer to `numpy.ndarray.repeat`
 |      for more information about the `repeats` argument.
 |      
 |      See also
 |      --------
 |      numpy.ndarray.repeat
 |  
 |  reset_index(self, level=None, drop=False, name=None, inplace=False)
 |      Analogous to the :meth:`pandas.DataFrame.reset_index` function, see
 |      docstring there.
 |      
 |      Parameters
 |      ----------
 |      level : int, str, tuple, or list, default None
 |          Only remove the given levels from the index. Removes all levels by
 |          default
 |      drop : boolean, default False
 |          Do not try to insert index into dataframe columns
 |      name : object, default None
 |          The name of the column corresponding to the Series values
 |      inplace : boolean, default False
 |          Modify the Series in place (do not create a new object)
 |      
 |      Returns
 |      ----------
 |      resetted : DataFrame, or Series if drop == True
 |  
 |  reshape(self, *args, **kwargs)
 |      DEPRECATED: calling this method will raise an error in a
 |      future release. Please call ``.values.reshape(...)`` instead.
 |      
 |      return an ndarray with the values shape
 |      if the specified shape matches exactly the current shape, then
 |      return self (for compat)
 |      
 |      See also
 |      --------
 |      numpy.ndarray.reshape
 |  
 |  rfloordiv(self, other, level=None, fill_value=None, axis=0)
 |      Integer division of series and other, element-wise (binary operator `rfloordiv`).
 |      
 |      Equivalent to ``other // series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.floordiv
 |  
 |  rmod(self, other, level=None, fill_value=None, axis=0)
 |      Modulo of series and other, element-wise (binary operator `rmod`).
 |      
 |      Equivalent to ``other % series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.mod
 |  
 |  rmul(self, other, level=None, fill_value=None, axis=0)
 |      Multiplication of series and other, element-wise (binary operator `rmul`).
 |      
 |      Equivalent to ``other * series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.mul
 |  
 |  rolling(self, window, min_periods=None, freq=None, center=False, win_type=None, on=None, axis=0, closed=None)
 |      Provides rolling window calculcations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int, or offset
 |          Size of the moving window. This is the number of observations used for
 |          calculating the statistic. Each window will be a fixed size.
 |      
 |          If its an offset then this will be the time period of each window. Each
 |          window will be a variable sized based on the observations included in
 |          the time-period. This is only valid for datetimelike indexes. This is
 |          new in 0.19.0
 |      min_periods : int, default None
 |          Minimum number of observations in window required to have a value
 |          (otherwise result is NA). For a window that is specified by an offset,
 |          this will default to 1.
 |      freq : string or DateOffset object, optional (default None) (DEPRECATED)
 |          Frequency to conform the data to before computing the statistic.
 |          Specified as a frequency string or DateOffset object.
 |      center : boolean, default False
 |          Set the labels at the center of the window.
 |      win_type : string, default None
 |          Provide a window type. See the notes below.
 |      on : string, optional
 |          For a DataFrame, column on which to calculate
 |          the rolling window, rather than the index
 |      closed : string, default None
 |          Make the interval closed on the 'right', 'left', 'both' or
 |          'neither' endpoints.
 |          For offset-based windows, it defaults to 'right'.
 |          For fixed windows, defaults to 'both'. Remaining cases not implemented
 |          for fixed windows.
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      axis : int or string, default 0
 |      
 |      Returns
 |      -------
 |      a Window or Rolling sub-classed for the particular operation
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]})
 |      >>> df
 |           B
 |      0  0.0
 |      1  1.0
 |      2  2.0
 |      3  NaN
 |      4  4.0
 |      
 |      Rolling sum with a window length of 2, using the 'triang'
 |      window type.
 |      
 |      >>> df.rolling(2, win_type='triang').sum()
 |           B
 |      0  NaN
 |      1  1.0
 |      2  2.5
 |      3  NaN
 |      4  NaN
 |      
 |      Rolling sum with a window length of 2, min_periods defaults
 |      to the window length.
 |      
 |      >>> df.rolling(2).sum()
 |           B
 |      0  NaN
 |      1  1.0
 |      2  3.0
 |      3  NaN
 |      4  NaN
 |      
 |      Same as above, but explicity set the min_periods
 |      
 |      >>> df.rolling(2, min_periods=1).sum()
 |           B
 |      0  0.0
 |      1  1.0
 |      2  3.0
 |      3  2.0
 |      4  4.0
 |      
 |      A ragged (meaning not-a-regular frequency), time-indexed DataFrame
 |      
 |      >>> df = pd.DataFrame({'B': [0, 1, 2, np.nan, 4]},
 |      ....:                 index = [pd.Timestamp('20130101 09:00:00'),
 |      ....:                          pd.Timestamp('20130101 09:00:02'),
 |      ....:                          pd.Timestamp('20130101 09:00:03'),
 |      ....:                          pd.Timestamp('20130101 09:00:05'),
 |      ....:                          pd.Timestamp('20130101 09:00:06')])
 |      
 |      >>> df
 |                             B
 |      2013-01-01 09:00:00  0.0
 |      2013-01-01 09:00:02  1.0
 |      2013-01-01 09:00:03  2.0
 |      2013-01-01 09:00:05  NaN
 |      2013-01-01 09:00:06  4.0
 |      
 |      
 |      Contrasting to an integer rolling window, this will roll a variable
 |      length window corresponding to the time period.
 |      The default for min_periods is 1.
 |      
 |      >>> df.rolling('2s').sum()
 |                             B
 |      2013-01-01 09:00:00  0.0
 |      2013-01-01 09:00:02  1.0
 |      2013-01-01 09:00:03  3.0
 |      2013-01-01 09:00:05  NaN
 |      2013-01-01 09:00:06  4.0
 |      
 |      Notes
 |      -----
 |      By default, the result is set to the right edge of the window. This can be
 |      changed to the center of the window by setting ``center=True``.
 |      
 |      The `freq` keyword is used to conform time series data to a specified
 |      frequency by resampling the data. This is done with the default parameters
 |      of :meth:`~pandas.Series.resample` (i.e. using the `mean`).
 |      
 |      To learn more about the offsets & frequency strings, please see `this link
 |      <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__.
 |      
 |      The recognized win_types are:
 |      
 |      * ``boxcar``
 |      * ``triang``
 |      * ``blackman``
 |      * ``hamming``
 |      * ``bartlett``
 |      * ``parzen``
 |      * ``bohman``
 |      * ``blackmanharris``
 |      * ``nuttall``
 |      * ``barthann``
 |      * ``kaiser`` (needs beta)
 |      * ``gaussian`` (needs std)
 |      * ``general_gaussian`` (needs power, width)
 |      * ``slepian`` (needs width).
 |  
 |  round(self, decimals=0, *args, **kwargs)
 |      Round each value in a Series to the given number of decimals.
 |      
 |      Parameters
 |      ----------
 |      decimals : int
 |          Number of decimal places to round to (default: 0).
 |          If decimals is negative, it specifies the number of
 |          positions to the left of the decimal point.
 |      
 |      Returns
 |      -------
 |      Series object
 |      
 |      See Also
 |      --------
 |      numpy.around
 |      DataFrame.round
 |  
 |  rpow(self, other, level=None, fill_value=None, axis=0)
 |      Exponential power of series and other, element-wise (binary operator `rpow`).
 |      
 |      Equivalent to ``other ** series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.pow
 |  
 |  rsub(self, other, level=None, fill_value=None, axis=0)
 |      Subtraction of series and other, element-wise (binary operator `rsub`).
 |      
 |      Equivalent to ``other - series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.sub
 |  
 |  rtruediv(self, other, level=None, fill_value=None, axis=0)
 |      Floating division of series and other, element-wise (binary operator `rtruediv`).
 |      
 |      Equivalent to ``other / series``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.truediv
 |  
 |  searchsorted(self, value, side='left', sorter=None)
 |      Find indices where elements should be inserted to maintain order.
 |      
 |      Find the indices into a sorted Series `self` such that, if the
 |      corresponding elements in `value` were inserted before the indices,
 |      the order of `self` would be preserved.
 |      
 |      Parameters
 |      ----------
 |      value : array_like
 |          Values to insert into `self`.
 |      side : {'left', 'right'}, optional
 |          If 'left', the index of the first suitable location found is given.
 |          If 'right', return the last such index.  If there is no suitable
 |          index, return either 0 or N (where N is the length of `self`).
 |      sorter : 1-D array_like, optional
 |          Optional array of integer indices that sort `self` into ascending
 |          order. They are typically the result of ``np.argsort``.
 |      
 |      Returns
 |      -------
 |      indices : array of ints
 |          Array of insertion points with the same shape as `value`.
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted
 |      
 |      Notes
 |      -----
 |      Binary search is used to find the required insertion points.
 |      
 |      Examples
 |      --------
 |      
 |      >>> x = pd.Series([1, 2, 3])
 |      >>> x
 |      0    1
 |      1    2
 |      2    3
 |      dtype: int64
 |      
 |      >>> x.searchsorted(4)
 |      array([3])
 |      
 |      >>> x.searchsorted([0, 4])
 |      array([0, 3])
 |      
 |      >>> x.searchsorted([1, 3], side='left')
 |      array([0, 2])
 |      
 |      >>> x.searchsorted([1, 3], side='right')
 |      array([1, 3])
 |      
 |      >>> x = pd.Categorical(['apple', 'bread', 'bread', 'cheese', 'milk' ])
 |      [apple, bread, bread, cheese, milk]
 |      Categories (4, object): [apple < bread < cheese < milk]
 |      
 |      >>> x.searchsorted('bread')
 |      array([1])     # Note: an array, not a scalar
 |      
 |      >>> x.searchsorted(['bread'])
 |      array([1])
 |      
 |      >>> x.searchsorted(['bread', 'eggs'])
 |      array([1, 4])
 |      
 |      >>> x.searchsorted(['bread', 'eggs'], side='right')
 |      array([3, 4])    # eggs before milk
 |  
 |  sem(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None, **kwargs)
 |      Return unbiased standard error of the mean over requested axis.
 |      
 |      Normalized by N-1 by default. This can be changed using the ddof argument
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      sem : scalar or Series (if level specified)
 |  
 |  set_value(self, label, value, takeable=False)
 |      Quickly set single value at passed label. If label is not contained, a
 |      new object is created with the label placed at the end of the result
 |      index
 |      
 |      Parameters
 |      ----------
 |      label : object
 |          Partial indexing with MultiIndex not allowed
 |      value : object
 |          Scalar value
 |      takeable : interpret the index as indexers, default False
 |      
 |      Returns
 |      -------
 |      series : Series
 |          If label is contained, will be reference to calling Series,
 |          otherwise a new object
 |  
 |  shift(self, periods=1, freq=None, axis=0)
 |      Shift index by desired number of periods with an optional time freq
 |      
 |      Parameters
 |      ----------
 |      periods : int
 |          Number of periods to move, can be positive or negative
 |      freq : DateOffset, timedelta, or time rule string, optional
 |          Increment to use from the tseries module or time rule (e.g. 'EOM').
 |          See Notes.
 |      axis : {0, 'index'}
 |      
 |      Notes
 |      -----
 |      If freq is specified then the index values are shifted but the data
 |      is not realigned. That is, use freq if you would like to extend the
 |      index when shifting and preserve the original data.
 |      
 |      Returns
 |      -------
 |      shifted : Series
 |  
 |  skew(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return unbiased skew over requested axis
 |      Normalized by N-1
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      skew : scalar or Series (if level specified)
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True)
 |      Sort object by labels (along an axis)
 |      
 |      Parameters
 |      ----------
 |      axis : index to direct sorting
 |      level : int or level name or list of ints or list of level names
 |          if not None, sort on values in specified index level(s)
 |      ascending : boolean, default True
 |          Sort ascending vs. descending
 |      inplace : bool, default False
 |          if True, perform operation in-place
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
 |           Choice of sorting algorithm. See also ndarray.np.sort for more
 |           information.  `mergesort` is the only stable algorithm. For
 |           DataFrames, this option is only applied when sorting on a single
 |           column or label.
 |      na_position : {'first', 'last'}, default 'last'
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end.
 |           Not implemented for MultiIndex.
 |      sort_remaining : bool, default True
 |          if true and sorting by level and index is multilevel, sort by other
 |          levels too (in order) after sorting by specified level
 |      
 |      Returns
 |      -------
 |      sorted_obj : Series
 |  
 |  sort_values(self, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 |      Sort by the values along either axis
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      axis : {0, 'index'}, default 0
 |          Axis to direct sorting
 |      ascending : bool or list of bool, default True
 |           Sort ascending vs. descending. Specify list for multiple sort
 |           orders.  If this is a list of bools, must match the length of
 |           the by.
 |      inplace : bool, default False
 |           if True, perform operation in-place
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, default 'quicksort'
 |           Choice of sorting algorithm. See also ndarray.np.sort for more
 |           information.  `mergesort` is the only stable algorithm. For
 |           DataFrames, this option is only applied when sorting on a single
 |           column or label.
 |      na_position : {'first', 'last'}, default 'last'
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      
 |      Returns
 |      -------
 |      sorted_obj : Series
 |  
 |  sortlevel(self, level=0, ascending=True, sort_remaining=True)
 |      DEPRECATED: use :meth:`Series.sort_index`
 |      
 |      Sort Series with MultiIndex by chosen level. Data will be
 |      lexicographically sorted by the chosen level followed by the other
 |      levels (in order)
 |      
 |      Parameters
 |      ----------
 |      level : int or level name, default None
 |      ascending : bool, default True
 |      
 |      Returns
 |      -------
 |      sorted : Series
 |      
 |      See Also
 |      --------
 |      Series.sort_index(level=...)
 |  
 |  std(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None, **kwargs)
 |      Return sample standard deviation over requested axis.
 |      
 |      Normalized by N-1 by default. This can be changed using the ddof argument
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      std : scalar or Series (if level specified)
 |  
 |  sub(self, other, level=None, fill_value=None, axis=0)
 |      Subtraction of series and other, element-wise (binary operator `sub`).
 |      
 |      Equivalent to ``series - other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rsub
 |  
 |  subtract = sub(self, other, level=None, fill_value=None, axis=0)
 |  
 |  sum(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |      Return the sum of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      sum : scalar or Series (if level specified)
 |  
 |  swaplevel(self, i=-2, j=-1, copy=True)
 |      Swap levels i and j in a MultiIndex
 |      
 |      Parameters
 |      ----------
 |      i, j : int, string (can be mixed)
 |          Level of index to be swapped. Can pass level name as string.
 |      
 |      Returns
 |      -------
 |      swapped : Series
 |      
 |      .. versionchanged:: 0.18.1
 |      
 |         The indexes ``i`` and ``j`` are now optional, and default to
 |         the two innermost levels of the index.
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=False, **kwargs)
 |      return Series corresponding to requested indices
 |      
 |      Parameters
 |      ----------
 |      indices : list / array of ints
 |      convert : translate negative to positive indices (default)
 |      
 |      Returns
 |      -------
 |      taken : Series
 |      
 |      See also
 |      --------
 |      numpy.ndarray.take
 |  
 |  to_csv(self, path=None, index=True, sep=',', na_rep='', float_format=None, header=False, index_label=None, mode='w', encoding=None, date_format=None, decimal='.')
 |      Write Series to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path : string or file handle, default None
 |          File path or object, if None is provided the result is returned as
 |          a string.
 |      na_rep : string, default ''
 |          Missing data representation
 |      float_format : string, default None
 |          Format string for floating point numbers
 |      header : boolean, default False
 |          Write out series name
 |      index : boolean, default True
 |          Write row names (index)
 |      index_label : string or sequence, default None
 |          Column label for index column(s) if desired. If None is given, and
 |          `header` and `index` are True, then the index names are used. A
 |          sequence should be given if the DataFrame uses MultiIndex.
 |      mode : Python write mode, default 'w'
 |      sep : character, default ","
 |          Field delimiter for the output file.
 |      encoding : string, optional
 |          a string representing the encoding to use if the contents are
 |          non-ascii, for python versions prior to 3
 |      date_format: string, default None
 |          Format string for datetime objects.
 |      decimal: string, default '.'
 |          Character recognized as decimal separator. E.g. use ',' for
 |          European data
 |  
 |  to_dict(self)
 |      Convert Series to {label -> value} dict
 |      
 |      Returns
 |      -------
 |      value_dict : dict
 |  
 |  to_excel(self, excel_writer, sheet_name='Sheet1', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, startrow=0, startcol=0, engine=None, merge_cells=True, encoding=None, inf_rep='inf', verbose=True)
 |      Write Series to an excel sheet
 |      
 |      .. versionadded:: 0.20.0
 |      
 |      
 |      Parameters
 |      ----------
 |      excel_writer : string or ExcelWriter object
 |          File path or existing ExcelWriter
 |      sheet_name : string, default 'Sheet1'
 |          Name of sheet which will contain DataFrame
 |      na_rep : string, default ''
 |          Missing data representation
 |      float_format : string, default None
 |          Format string for floating point numbers
 |      columns : sequence, optional
 |          Columns to write
 |      header : boolean or list of string, default True
 |          Write out column names. If a list of string is given it is
 |          assumed to be aliases for the column names
 |      index : boolean, default True
 |          Write row names (index)
 |      index_label : string or sequence, default None
 |          Column label for index column(s) if desired. If None is given, and
 |          `header` and `index` are True, then the index names are used. A
 |          sequence should be given if the DataFrame uses MultiIndex.
 |      startrow :
 |          upper left cell row to dump data frame
 |      startcol :
 |          upper left cell column to dump data frame
 |      engine : string, default None
 |          write engine to use - you can also set this via the options
 |          ``io.excel.xlsx.writer``, ``io.excel.xls.writer``, and
 |          ``io.excel.xlsm.writer``.
 |      merge_cells : boolean, default True
 |          Write MultiIndex and Hierarchical Rows as merged cells.
 |      encoding: string, default None
 |          encoding of the resulting excel file. Only necessary for xlwt,
 |          other writers support unicode natively.
 |      inf_rep : string, default 'inf'
 |          Representation for infinity (there is no native representation for
 |          infinity in Excel)
 |      freeze_panes : tuple of integer (length 2), default None
 |          Specifies the one-based bottommost row and rightmost column that
 |          is to be frozen
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      Notes
 |      -----
 |      If passing an existing ExcelWriter object, then the sheet will be added
 |      to the existing workbook.  This can be used to save different
 |      DataFrames to one workbook:
 |      
 |      >>> writer = pd.ExcelWriter('output.xlsx')
 |      >>> df1.to_excel(writer,'Sheet1')
 |      >>> df2.to_excel(writer,'Sheet2')
 |      >>> writer.save()
 |      
 |      For compatibility with to_csv, to_excel serializes lists and dicts to
 |      strings before writing.
 |  
 |  to_frame(self, name=None)
 |      Convert Series to DataFrame
 |      
 |      Parameters
 |      ----------
 |      name : object, default None
 |          The passed name should substitute for the series name (if it has
 |          one).
 |      
 |      Returns
 |      -------
 |      data_frame : DataFrame
 |  
 |  to_period(self, freq=None, copy=True)
 |      Convert Series from DatetimeIndex to PeriodIndex with desired
 |      frequency (inferred from index if not passed)
 |      
 |      Parameters
 |      ----------
 |      freq : string, default
 |      
 |      Returns
 |      -------
 |      ts : Series with PeriodIndex
 |  
 |  to_sparse(self, kind='block', fill_value=None)
 |      Convert Series to SparseSeries
 |      
 |      Parameters
 |      ----------
 |      kind : {'block', 'integer'}
 |      fill_value : float, defaults to NaN (missing)
 |      
 |      Returns
 |      -------
 |      sp : SparseSeries
 |  
 |  to_string(self, buf=None, na_rep='NaN', float_format=None, header=True, index=True, length=False, dtype=False, name=False, max_rows=None)
 |      Render a string representation of the Series
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats
 |          default None
 |      header: boolean, default True
 |          Add the Series header (index name)
 |      index : bool, optional
 |          Add index (row) labels, default True
 |      length : boolean, default False
 |          Add the Series length
 |      dtype : boolean, default False
 |          Add the Series dtype
 |      name : boolean, default False
 |          Add the Series name if not None
 |      max_rows : int, optional
 |          Maximum number of rows to show before truncating. If None, show
 |          all.
 |      
 |      Returns
 |      -------
 |      formatted : string (if not buffer passed)
 |  
 |  to_timestamp(self, freq=None, how='start', copy=True)
 |      Cast to datetimeindex of timestamps, at *beginning* of period
 |      
 |      Parameters
 |      ----------
 |      freq : string, default frequency of PeriodIndex
 |          Desired frequency
 |      how : {'s', 'e', 'start', 'end'}
 |          Convention for converting period to timestamp; start of period
 |          vs. end
 |      
 |      Returns
 |      -------
 |      ts : Series with DatetimeIndex
 |  
 |  tolist(self)
 |      Convert Series to a nested list
 |  
 |  transform(self, func, *args, **kwargs)
 |      Call function producing a like-indexed NDFrame
 |      and return a NDFrame with the transformed values`
 |      
 |      .. versionadded:: 0.20.0
 |      
 |      Parameters
 |      ----------
 |      func : callable, string, dictionary, or list of string/callables
 |          To apply to column
 |      
 |          Accepted Combinations are:
 |      
 |          - string function name
 |          - function
 |          - list of functions
 |          - dict of column names -> functions (or list of functions)
 |      
 |      Returns
 |      -------
 |      transformed : NDFrame
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame(np.random.randn(10, 3), columns=['A', 'B', 'C'],
 |      ...                   index=pd.date_range('1/1/2000', periods=10))
 |      df.iloc[3:7] = np.nan
 |      
 |      >>> df.transform(lambda x: (x - x.mean()) / x.std())
 |                         A         B         C
 |      2000-01-01  0.579457  1.236184  0.123424
 |      2000-01-02  0.370357 -0.605875 -1.231325
 |      2000-01-03  1.455756 -0.277446  0.288967
 |      2000-01-04       NaN       NaN       NaN
 |      2000-01-05       NaN       NaN       NaN
 |      2000-01-06       NaN       NaN       NaN
 |      2000-01-07       NaN       NaN       NaN
 |      2000-01-08 -0.498658  1.274522  1.642524
 |      2000-01-09 -0.540524 -1.012676 -0.828968
 |      2000-01-10 -1.366388 -0.614710  0.005378
 |      
 |      See also
 |      --------
 |      pandas.NDFrame.aggregate
 |      pandas.NDFrame.apply
 |  
 |  truediv(self, other, level=None, fill_value=None, axis=0)
 |      Floating division of series and other, element-wise (binary operator `truediv`).
 |      
 |      Equivalent to ``series / other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series or scalar value
 |      fill_value : None or float value, default None (NaN)
 |          Fill missing (NaN) values with this value. If both Series are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Returns
 |      -------
 |      result : Series
 |      
 |      See also
 |      --------
 |      Series.rtruediv
 |  
 |  unique(self)
 |      Return unique values in the object. Uniques are returned in order
 |      of appearance, this does NOT sort. Hash table-based unique.
 |      
 |      Parameters
 |      ----------
 |      values : 1d array-like
 |      
 |      Returns
 |      -------
 |      unique values.
 |        - If the input is an Index, the return is an Index
 |        - If the input is a Categorical dtype, the return is a Categorical
 |        - If the input is a Series/ndarray, the return will be an ndarray
 |      
 |      See Also
 |      --------
 |      unique
 |      Index.unique
 |      Series.unique
 |  
 |  unstack(self, level=-1, fill_value=None)
 |      Unstack, a.k.a. pivot, Series with MultiIndex to produce DataFrame.
 |      The level involved will automatically get sorted.
 |      
 |      Parameters
 |      ----------
 |      level : int, string, or list of these, default last level
 |          Level(s) to unstack, can pass level name
 |      fill_value : replace NaN with this value if the unstack produces
 |          missing values
 |      
 |          .. versionadded: 0.18.0
 |      
 |      Examples
 |      --------
 |      >>> s = pd.Series([1, 2, 3, 4],
 |      ...     index=pd.MultiIndex.from_product([['one', 'two'], ['a', 'b']]))
 |      >>> s
 |      one  a    1
 |           b    2
 |      two  a    3
 |           b    4
 |      dtype: int64
 |      
 |      >>> s.unstack(level=-1)
 |           a  b
 |      one  1  2
 |      two  3  4
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a    1    3
 |      b    2    4
 |      
 |      Returns
 |      -------
 |      unstacked : DataFrame
 |  
 |  update(self, other)
 |      Modify Series in place using non-NA values from passed
 |      Series. Aligns on index
 |      
 |      Parameters
 |      ----------
 |      other : Series
 |  
 |  valid lambda self, inplace=False, **kwargs
 |  
 |  var(self, axis=None, skipna=None, level=None, ddof=1, numeric_only=None, **kwargs)
 |      Return unbiased variance over requested axis.
 |      
 |      Normalized by N-1 by default. This can be changed using the ddof argument
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a scalar
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean columns. If None, will attempt to use
 |          everything, then use only numeric data. Not implemented for Series.
 |      
 |      Returns
 |      -------
 |      var : scalar or Series (if level specified)
 |  
 |  view(self, dtype=None)
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_array(arr, index=None, name=None, dtype=None, copy=False, fastpath=False) from builtins.type
 |  
 |  from_csv(path, sep=',', parse_dates=True, header=None, index_col=0, encoding=None, infer_datetime_format=False) from builtins.type
 |      Read CSV file (DISCOURAGED, please use :func:`pandas.read_csv`
 |      instead).
 |      
 |      It is preferable to use the more powerful :func:`pandas.read_csv`
 |      for most general purposes, but ``from_csv`` makes for an easy
 |      roundtrip to and from a file (the exact counterpart of
 |      ``to_csv``), especially with a time Series.
 |      
 |      This method only differs from :func:`pandas.read_csv` in some defaults:
 |      
 |      - `index_col` is ``0`` instead of ``None`` (take first column as index
 |        by default)
 |      - `header` is ``None`` instead of ``0`` (the first row is not used as
 |        the column names)
 |      - `parse_dates` is ``True`` instead of ``False`` (try parsing the index
 |        as datetime by default)
 |      
 |      With :func:`pandas.read_csv`, the option ``squeeze=True`` can be used
 |      to return a Series like ``from_csv``.
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO
 |      sep : string, default ','
 |          Field delimiter
 |      parse_dates : boolean, default True
 |          Parse dates. Different default from read_table
 |      header : int, default None
 |          Row to use as header (skip prior rows)
 |      index_col : int or sequence, default 0
 |          Column to use for index. If a sequence is given, a MultiIndex
 |          is used. Different default from read_table
 |      encoding : string, optional
 |          a string representing the encoding to use if the contents are
 |          non-ascii, for python versions prior to 3
 |      infer_datetime_format: boolean, default False
 |          If True and `parse_dates` is True for a column, try to infer the
 |          datetime format based on the first datetime string. If the format
 |          can be inferred, there often will be a large parsing speed-up.
 |      
 |      See also
 |      --------
 |      pandas.read_csv
 |      
 |      Returns
 |      -------
 |      y : Series
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  asobject
 |      return object Series which contains boxed values
 |      
 |      *this is an internal non-public method*
 |  
 |  axes
 |      Return a list of the row axis labels
 |  
 |  dtype
 |      return the dtype object of the underlying data
 |  
 |  dtypes
 |      return the dtype object of the underlying data
 |  
 |  ftype
 |      return if the data is sparse|dense
 |  
 |  ftypes
 |      return if the data is sparse|dense
 |  
 |  imag
 |  
 |  index
 |  
 |  name
 |  
 |  real
 |  
 |  values
 |      Return Series as ndarray or ndarray-like
 |      depending on the dtype
 |      
 |      Returns
 |      -------
 |      arr : numpy.ndarray or ndarray-like
 |      
 |      Examples
 |      --------
 |      >>> pd.Series([1, 2, 3]).values
 |      array([1, 2, 3])
 |      
 |      >>> pd.Series(list('aabc')).values
 |      array(['a', 'a', 'b', 'c'], dtype=object)
 |      
 |      >>> pd.Series(list('aabc')).astype('category').values
 |      [a, a, b, c]
 |      Categories (3, object): [a, b, c]
 |      
 |      Timezone aware datetime data is converted to UTC:
 |      
 |      >>> pd.Series(pd.date_range('20130101', periods=3,
 |      ...                         tz='US/Eastern')).values
 |      array(['2013-01-01T05:00:00.000000000',
 |             '2013-01-02T05:00:00.000000000',
 |             '2013-01-03T05:00:00.000000000'], dtype='datetime64[ns]')
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  cat = <class 'pandas.core.categorical.CategoricalAccessor'>
 |      Accessor object for categorical properties of the Series values.
 |      
 |      Be aware that assigning to `categories` is a inplace operation, while all
 |      methods return new categorical data per default (but can be called with
 |      `inplace=True`).
 |      
 |      Examples
 |      --------
 |      >>> s.cat.categories
 |      >>> s.cat.categories = list('abc')
 |      >>> s.cat.rename_categories(list('cab'))
 |      >>> s.cat.reorder_categories(list('cab'))
 |      >>> s.cat.add_categories(['d','e'])
 |      >>> s.cat.remove_categories(['d'])
 |      >>> s.cat.remove_unused_categories()
 |      >>> s.cat.set_categories(list('abcde'))
 |      >>> s.cat.as_ordered()
 |      >>> s.cat.as_unordered()
 |  
 |  dt = <class 'pandas.core.indexes.accessors.CombinedDatetimelikePropert...
 |      Accessor object for datetimelike properties of the Series values.
 |      
 |      Examples
 |      --------
 |      >>> s.dt.hour
 |      >>> s.dt.second
 |      >>> s.dt.quarter
 |      
 |      Returns a Series indexed like the original Series.
 |      Raises TypeError if the Series does not contain datetimelike values.
 |  
 |  plot = <class 'pandas.plotting._core.SeriesPlotMethods'>
 |      Series plotting accessor and method
 |      
 |      Examples
 |      --------
 |      >>> s.plot.line()
 |      >>> s.plot.bar()
 |      >>> s.plot.hist()
 |      
 |      Plotting methods can also be accessed by calling the accessor as a method
 |      with the ``kind`` argument:
 |      ``s.plot(kind='line')`` is equivalent to ``s.plot.line()``
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.base.IndexOpsMixin:
 |  
 |  factorize(self, sort=False, na_sentinel=-1)
 |      Encode the object as an enumerated type or categorical variable
 |      
 |      Parameters
 |      ----------
 |      sort : boolean, default False
 |          Sort by values
 |      na_sentinel: int, default -1
 |          Value to mark "not found"
 |      
 |      Returns
 |      -------
 |      labels : the indexer to the original array
 |      uniques : the unique Index
 |  
 |  item(self)
 |      return the first element of the underlying data as a python
 |      scalar
 |  
 |  nunique(self, dropna=True)
 |      Return number of unique elements in the object.
 |      
 |      Excludes NA values by default.
 |      
 |      Parameters
 |      ----------
 |      dropna : boolean, default True
 |          Don't include NaN in the count.
 |      
 |      Returns
 |      -------
 |      nunique : int
 |  
 |  transpose(self, *args, **kwargs)
 |      return the transpose, which is by definition self
 |  
 |  value_counts(self, normalize=False, sort=True, ascending=False, bins=None, dropna=True)
 |      Returns object containing counts of unique values.
 |      
 |      The resulting object will be in descending order so that the
 |      first element is the most frequently-occurring element.
 |      Excludes NA values by default.
 |      
 |      Parameters
 |      ----------
 |      normalize : boolean, default False
 |          If True then the object returned will contain the relative
 |          frequencies of the unique values.
 |      sort : boolean, default True
 |          Sort by values
 |      ascending : boolean, default False
 |          Sort in ascending order
 |      bins : integer, optional
 |          Rather than count values, group them into half-open bins,
 |          a convenience for pd.cut, only works with numeric data
 |      dropna : boolean, default True
 |          Don't include counts of NaN.
 |      
 |      Returns
 |      -------
 |      counts : Series
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pandas.core.base.IndexOpsMixin:
 |  
 |  T
 |      return the transpose, which is by definition self
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  base
 |      return the base object if the memory of the underlying data is
 |      shared
 |  
 |  data
 |      return the data pointer of the underlying data
 |  
 |  empty
 |  
 |  flags
 |      return the ndarray.flags for the underlying data
 |  
 |  hasnans
 |  
 |  is_monotonic
 |      Return boolean if values in the object are
 |      monotonic_increasing
 |      
 |      .. versionadded:: 0.19.0
 |      
 |      Returns
 |      -------
 |      is_monotonic : boolean
 |  
 |  is_monotonic_decreasing
 |      Return boolean if values in the object are
 |      monotonic_decreasing
 |      
 |      .. versionadded:: 0.19.0
 |      
 |      Returns
 |      -------
 |      is_monotonic_decreasing : boolean
 |  
 |  is_monotonic_increasing
 |      Return boolean if values in the object are
 |      monotonic_increasing
 |      
 |      .. versionadded:: 0.19.0
 |      
 |      Returns
 |      -------
 |      is_monotonic : boolean
 |  
 |  is_unique
 |      Return boolean if values in the object are unique
 |      
 |      Returns
 |      -------
 |      is_unique : boolean
 |  
 |  itemsize
 |      return the size of the dtype of the item of the underlying data
 |  
 |  nbytes
 |      return the number of bytes in the underlying data
 |  
 |  ndim
 |      return the number of dimensions of the underlying data,
 |      by definition 1
 |  
 |  shape
 |      return a tuple of the shape of the underlying data
 |  
 |  size
 |      return the number of elements in the underlying data
 |  
 |  strides
 |      return the strides of the underlying data
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from pandas.core.base.IndexOpsMixin:
 |  
 |  __array_priority__ = 1000
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from pandas.core.strings.StringAccessorMixin:
 |  
 |  str = <class 'pandas.core.strings.StringMethods'>
 |      Vectorized string functions for Series and Index. NAs stay NA unless
 |      handled otherwise by a particular method. Patterned after Python's string
 |      methods, with some inspiration from R's stringr package.
 |      
 |      Examples
 |      --------
 |      >>> s.str.split('_')
 |      >>> s.str.replace('_', '')
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.generic.NDFrame:
 |  
 |  __abs__(self)
 |  
 |  __bool__ = __nonzero__(self)
 |  
 |  __contains__(self, key)
 |      True if the key is in the info axis
 |  
 |  __copy__(self, deep=True)
 |  
 |  __deepcopy__(self, memo=None)
 |  
 |  __delitem__(self, key)
 |      Delete item
 |  
 |  __finalize__(self, other, method=None, **kwargs)
 |      Propagate metadata from other to self.
 |      
 |      Parameters
 |      ----------
 |      other : the object from which to get the attributes that we are going
 |          to propagate
 |      method : optional, a passed method name ; possibly to take different
 |          types of propagation actions based on this
 |  
 |  __getattr__(self, name)
 |      After regular attribute access, try looking up the name
 |      This allows simpler access to columns for interactive use.
 |  
 |  __getstate__(self)
 |  
 |  __hash__(self)
 |      Return hash(self).
 |  
 |  __invert__(self)
 |  
 |  __neg__(self)
 |  
 |  __nonzero__(self)
 |  
 |  __round__(self, decimals=0)
 |  
 |  __setattr__(self, name, value)
 |      After regular attribute access, try setting the name
 |      This allows simpler access to columns for interactive use.
 |  
 |  __setstate__(self, state)
 |  
 |  abs(self)
 |      Return an object with absolute value taken--only applicable to objects
 |      that are all numeric.
 |      
 |      Returns
 |      -------
 |      abs: type of caller
 |  
 |  add_prefix(self, prefix)
 |      Concatenate prefix string with panel items names.
 |      
 |      Parameters
 |      ----------
 |      prefix : string
 |      
 |      Returns
 |      -------
 |      with_prefix : type of caller
 |  
 |  add_suffix(self, suffix)
 |      Concatenate suffix string with panel items names.
 |      
 |      Parameters
 |      ----------
 |      suffix : string
 |      
 |      Returns
 |      -------
 |      with_suffix : type of caller
 |  
 |  as_blocks(self, copy=True)
 |      Convert the frame to a dict of dtype -> Constructor Types that each has
 |      a homogeneous dtype.
 |      
 |      NOTE: the dtypes of the blocks WILL BE PRESERVED HERE (unlike in
 |            as_matrix)
 |      
 |      Parameters
 |      ----------
 |      copy : boolean, default True
 |      
 |             .. versionadded: 0.16.1
 |      
 |      Returns
 |      -------
 |      values : a dict of dtype -> Constructor Types
 |  
 |  as_matrix(self, columns=None)
 |      Convert the frame to its Numpy-array representation.
 |      
 |      Parameters
 |      ----------
 |      columns: list, optional, default:None
 |          If None, return all columns, otherwise, returns specified columns.
 |      
 |      Returns
 |      -------
 |      values : ndarray
 |          If the caller is heterogeneous and contains booleans or objects,
 |          the result will be of dtype=object. See Notes.
 |      
 |      
 |      Notes
 |      -----
 |      Return is NOT a Numpy-matrix, rather, a Numpy-array.
 |      
 |      The dtype will be a lower-common-denominator dtype (implicit
 |      upcasting); that is to say if the dtypes (even of numeric types)
 |      are mixed, the one that accommodates all will be chosen. Use this
 |      with care if you are not dealing with the blocks.
 |      
 |      e.g. If the dtypes are float16 and float32, dtype will be upcast to
 |      float32.  If dtypes are int32 and uint8, dtype will be upcase to
 |      int32. By numpy.find_common_type convention, mixing int64 and uint64
 |      will result in a flot64 dtype.
 |      
 |      This method is provided for backwards compatibility. Generally,
 |      it is recommended to use '.values'.
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.values
 |  
 |  asfreq(self, freq, method=None, how=None, normalize=False, fill_value=None)
 |      Convert TimeSeries to specified frequency.
 |      
 |      Optionally provide filling method to pad/backfill missing values.
 |      
 |      Returns the original data conformed to a new index with the specified
 |      frequency. ``resample`` is more appropriate if an operation, such as
 |      summarization, is necessary to represent the data at the new frequency.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill'/'bfill', 'pad'/'ffill'}, default None
 |          Method to use for filling holes in reindexed Series (note this
 |          does not fill NaNs that already were present):
 |      
 |          * 'pad' / 'ffill': propagate last valid observation forward to next
 |            valid
 |          * 'backfill' / 'bfill': use NEXT valid observation to fill
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      fill_value: scalar, optional
 |          Value to use for missing values, applied during upsampling (note
 |          this does not fill NaNs that already were present).
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |      
 |      Examples
 |      --------
 |      
 |      Start by creating a series with 4 one minute timestamps.
 |      
 |      >>> index = pd.date_range('1/1/2000', periods=4, freq='T')
 |      >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)
 |      >>> df = pd.DataFrame({'s':series})
 |      >>> df
 |                             s
 |      2000-01-01 00:00:00    0.0
 |      2000-01-01 00:01:00    NaN
 |      2000-01-01 00:02:00    2.0
 |      2000-01-01 00:03:00    3.0
 |      
 |      Upsample the series into 30 second bins.
 |      
 |      >>> df.asfreq(freq='30S')
 |                             s
 |      2000-01-01 00:00:00    0.0
 |      2000-01-01 00:00:30    NaN
 |      2000-01-01 00:01:00    NaN
 |      2000-01-01 00:01:30    NaN
 |      2000-01-01 00:02:00    2.0
 |      2000-01-01 00:02:30    NaN
 |      2000-01-01 00:03:00    3.0
 |      
 |      Upsample again, providing a ``fill value``.
 |      
 |      >>> df.asfreq(freq='30S', fill_value=9.0)
 |                             s
 |      2000-01-01 00:00:00    0.0
 |      2000-01-01 00:00:30    9.0
 |      2000-01-01 00:01:00    NaN
 |      2000-01-01 00:01:30    9.0
 |      2000-01-01 00:02:00    2.0
 |      2000-01-01 00:02:30    9.0
 |      2000-01-01 00:03:00    3.0
 |      
 |      Upsample again, providing a ``method``.
 |      
 |      >>> df.asfreq(freq='30S', method='bfill')
 |                             s
 |      2000-01-01 00:00:00    0.0
 |      2000-01-01 00:00:30    NaN
 |      2000-01-01 00:01:00    NaN
 |      2000-01-01 00:01:30    2.0
 |      2000-01-01 00:02:00    2.0
 |      2000-01-01 00:02:30    3.0
 |      2000-01-01 00:03:00    3.0
 |      
 |      See Also
 |      --------
 |      reindex
 |      
 |      Notes
 |      -----
 |      To learn more about the frequency strings, please see `this link
 |      <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__.
 |  
 |  asof(self, where, subset=None)
 |      The last row without any NaN is taken (or the last row without
 |      NaN considering only the subset of columns in the case of a DataFrame)
 |      
 |      .. versionadded:: 0.19.0 For DataFrame
 |      
 |      If there is no good value, NaN is returned for a Series
 |      a Series of NaN values for a DataFrame
 |      
 |      Parameters
 |      ----------
 |      where : date or array of dates
 |      subset : string or list of strings, default None
 |         if not None use these columns for NaN propagation
 |      
 |      Notes
 |      -----
 |      Dates are assumed to be sorted
 |      Raises if this is not the case
 |      
 |      Returns
 |      -------
 |      where is scalar
 |      
 |        - value or NaN if input is Series
 |        - Series if input is DataFrame
 |      
 |      where is Index: same shape object as input
 |      
 |      See Also
 |      --------
 |      merge_asof
 |  
 |  astype(self, dtype, copy=True, errors='raise', **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : data type, or dict of column name -> data type
 |          Use a numpy.dtype or Python type to cast entire pandas object to
 |          the same type. Alternatively, use {col: dtype, ...}, where col is a
 |          column label and dtype is a numpy.dtype or Python type to cast one
 |          or more of the DataFrame's columns to column-specific types.
 |      errors : {'raise', 'ignore'}, default 'raise'.
 |          Control raising of exceptions on invalid data for provided dtype.
 |      
 |          - ``raise`` : allow exceptions to be raised
 |          - ``ignore`` : suppress exceptions. On error return original object
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      raise_on_error : DEPRECATED use ``errors`` instead
 |      kwargs : keyword arguments to pass on to the constructor
 |      
 |      Returns
 |      -------
 |      casted : type of caller
 |  
 |  at_time(self, time, asof=False)
 |      Select values at particular time of day (e.g. 9:30AM).
 |      
 |      Parameters
 |      ----------
 |      time : datetime.time or string
 |      
 |      Returns
 |      -------
 |      values_at_time : type of caller
 |  
 |  between_time(self, start_time, end_time, include_start=True, include_end=True)
 |      Select values between particular times of the day (e.g., 9:00-9:30 AM).
 |      
 |      Parameters
 |      ----------
 |      start_time : datetime.time or string
 |      end_time : datetime.time or string
 |      include_start : boolean, default True
 |      include_end : boolean, default True
 |      
 |      Returns
 |      -------
 |      values_between_time : type of caller
 |  
 |  bfill(self, axis=None, inplace=False, limit=None, downcast=None)
 |      Synonym for :meth:`DataFrame.fillna(method='bfill') <DataFrame.fillna>`
 |  
 |  bool(self)
 |      Return the bool of a single element PandasObject.
 |      
 |      This must be a boolean scalar value, either True or False.  Raise a
 |      ValueError if the PandasObject does not have exactly 1 element, or that
 |      element is not boolean
 |  
 |  clip(self, lower=None, upper=None, axis=None, *args, **kwargs)
 |      Trim values at input threshold(s).
 |      
 |      Parameters
 |      ----------
 |      lower : float or array_like, default None
 |      upper : float or array_like, default None
 |      axis : int or string axis name, optional
 |          Align object with lower and upper along the given axis.
 |      
 |      Returns
 |      -------
 |      clipped : Series
 |      
 |      Examples
 |      --------
 |      >>> df
 |                0         1
 |      0  0.335232 -1.256177
 |      1 -1.367855  0.746646
 |      2  0.027753 -1.176076
 |      3  0.230930 -0.679613
 |      4  1.261967  0.570967
 |      
 |      >>> df.clip(-1.0, 0.5)
 |                0         1
 |      0  0.335232 -1.000000
 |      1 -1.000000  0.500000
 |      2  0.027753 -1.000000
 |      3  0.230930 -0.679613
 |      4  0.500000  0.500000
 |      
 |      >>> t
 |      0   -0.3
 |      1   -0.2
 |      2   -0.1
 |      3    0.0
 |      4    0.1
 |      dtype: float64
 |      
 |      >>> df.clip(t, t + 1, axis=0)
 |                0         1
 |      0  0.335232 -0.300000
 |      1 -0.200000  0.746646
 |      2  0.027753 -0.100000
 |      3  0.230930  0.000000
 |      4  1.100000  0.570967
 |  
 |  clip_lower(self, threshold, axis=None)
 |      Return copy of the input with values below given value(s) truncated.
 |      
 |      Parameters
 |      ----------
 |      threshold : float or array_like
 |      axis : int or string axis name, optional
 |          Align object with threshold along the given axis.
 |      
 |      See Also
 |      --------
 |      clip
 |      
 |      Returns
 |      -------
 |      clipped : same type as input
 |  
 |  clip_upper(self, threshold, axis=None)
 |      Return copy of input with values above given value(s) truncated.
 |      
 |      Parameters
 |      ----------
 |      threshold : float or array_like
 |      axis : int or string axis name, optional
 |          Align object with threshold along the given axis.
 |      
 |      See Also
 |      --------
 |      clip
 |      
 |      Returns
 |      -------
 |      clipped : same type as input
 |  
 |  consolidate(self, inplace=False)
 |      DEPRECATED: consolidate will be an internal implementation only.
 |  
 |  convert_objects(self, convert_dates=True, convert_numeric=False, convert_timedeltas=True, copy=True)
 |      Deprecated.
 |      
 |      Attempt to infer better dtype for object columns
 |      
 |      Parameters
 |      ----------
 |      convert_dates : boolean, default True
 |          If True, convert to date where possible. If 'coerce', force
 |          conversion, with unconvertible values becoming NaT.
 |      convert_numeric : boolean, default False
 |          If True, attempt to coerce to numbers (including strings), with
 |          unconvertible values becoming NaN.
 |      convert_timedeltas : boolean, default True
 |          If True, convert to timedelta where possible. If 'coerce', force
 |          conversion, with unconvertible values becoming NaT.
 |      copy : boolean, default True
 |          If True, return a copy even if no copy is necessary (e.g. no
 |          conversion was done). Note: This is meant for internal use, and
 |          should not be confused with inplace.
 |      
 |      See Also
 |      --------
 |      pandas.to_datetime : Convert argument to datetime.
 |      pandas.to_timedelta : Convert argument to timedelta.
 |      pandas.to_numeric : Return a fixed frequency timedelta index,
 |          with day as the default.
 |      
 |      Returns
 |      -------
 |      converted : same as input object
 |  
 |  copy(self, deep=True)
 |      Make a copy of this objects data.
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, including a copy of the data and the indices.
 |          With ``deep=False`` neither the indices or the data are copied.
 |      
 |          Note that when ``deep=True`` data is copied, actual python objects
 |          will not be copied recursively, only the reference to the object.
 |          This is in contrast to ``copy.deepcopy`` in the Standard Library,
 |          which recursively copies object data.
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generates descriptive statistics that summarize the central tendency,
 |      dispersion and shape of a dataset's distribution, excluding
 |      ``NaN`` values.
 |      
 |      Analyzes both numeric and object series, as well
 |      as ``DataFrame`` column sets of mixed data types. The output
 |      will vary depending on what is provided. Refer to the notes
 |      below for more detail.
 |      
 |      Parameters
 |      ----------
 |      percentiles : list-like of numbers, optional
 |          The percentiles to include in the output. All should
 |          fall between 0 and 1. The default is
 |          ``[.25, .5, .75]``, which returns the 25th, 50th, and
 |          75th percentiles.
 |      include : 'all', list-like of dtypes or None (default), optional
 |          A white list of data types to include in the result. Ignored
 |          for ``Series``. Here are the options:
 |      
 |          - 'all' : All columns of the input will be included in the output.
 |          - A list-like of dtypes : Limits the results to the
 |            provided data types.
 |            To limit the result to numeric types submit
 |            ``numpy.number``. To limit it instead to categorical
 |            objects submit the ``numpy.object`` data type. Strings
 |            can also be used in the style of
 |            ``select_dtypes`` (e.g. ``df.describe(include=['O'])``)
 |          - None (default) : The result will include all numeric columns.
 |      exclude : list-like of dtypes or None (default), optional,
 |          A black list of data types to omit from the result. Ignored
 |          for ``Series``. Here are the options:
 |      
 |          - A list-like of dtypes : Excludes the provided data types
 |            from the result. To select numeric types submit
 |            ``numpy.number``. To select categorical objects submit the data
 |            type ``numpy.object``. Strings can also be used in the style of
 |            ``select_dtypes`` (e.g. ``df.describe(include=['O'])``)
 |          - None (default) : The result will exclude nothing.
 |      
 |      Returns
 |      -------
 |      summary:  Series/DataFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      For numeric data, the result's index will include ``count``,
 |      ``mean``, ``std``, ``min``, ``max`` as well as lower, ``50`` and
 |      upper percentiles. By default the lower percentile is ``25`` and the
 |      upper percentile is ``75``. The ``50`` percentile is the
 |      same as the median.
 |      
 |      For object data (e.g. strings or timestamps), the result's index
 |      will include ``count``, ``unique``, ``top``, and ``freq``. The ``top``
 |      is the most common value. The ``freq`` is the most common value's
 |      frequency. Timestamps also include the ``first`` and ``last`` items.
 |      
 |      If multiple object values have the highest count, then the
 |      ``count`` and ``top`` results will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      For mixed data types provided via a ``DataFrame``, the default is to
 |      return only an analysis of numeric columns. If ``include='all'``
 |      is provided as an option, the result will include a union of
 |      attributes of each type.
 |      
 |      The `include` and `exclude` parameters can be used to limit
 |      which columns in a ``DataFrame`` are analyzed for the output.
 |      The parameters are ignored when analyzing a ``Series``.
 |      
 |      Examples
 |      --------
 |      Describing a numeric ``Series``.
 |      
 |      >>> s = pd.Series([1, 2, 3])
 |      >>> s.describe()
 |      count    3.0
 |      mean     2.0
 |      std      1.0
 |      min      1.0
 |      25%      1.5
 |      50%      2.0
 |      75%      2.5
 |      max      3.0
 |      
 |      Describing a categorical ``Series``.
 |      
 |      >>> s = pd.Series(['a', 'a', 'b', 'c'])
 |      >>> s.describe()
 |      count     4
 |      unique    3
 |      top       a
 |      freq      2
 |      dtype: object
 |      
 |      Describing a timestamp ``Series``.
 |      
 |      >>> s = pd.Series([
 |      ...   np.datetime64("2000-01-01"),
 |      ...   np.datetime64("2010-01-01"),
 |      ...   np.datetime64("2010-01-01")
 |      ... ])
 |      >>> s.describe()
 |      count                       3
 |      unique                      2
 |      top       2010-01-01 00:00:00
 |      freq                        2
 |      first     2000-01-01 00:00:00
 |      last      2010-01-01 00:00:00
 |      dtype: object
 |      
 |      Describing a ``DataFrame``. By default only numeric fields
 |      are returned.
 |      
 |      >>> df = pd.DataFrame([[1, 'a'], [2, 'b'], [3, 'c']],
 |      ...                   columns=['numeric', 'object'])
 |      >>> df.describe()
 |             numeric
 |      count      3.0
 |      mean       2.0
 |      std        1.0
 |      min        1.0
 |      25%        1.5
 |      50%        2.0
 |      75%        2.5
 |      max        3.0
 |      
 |      Describing all columns of a ``DataFrame`` regardless of data type.
 |      
 |      >>> df.describe(include='all')
 |              numeric object
 |      count       3.0      3
 |      unique      NaN      3
 |      top         NaN      b
 |      freq        NaN      1
 |      mean        2.0    NaN
 |      std         1.0    NaN
 |      min         1.0    NaN
 |      25%         1.5    NaN
 |      50%         2.0    NaN
 |      75%         2.5    NaN
 |      max         3.0    NaN
 |      
 |      Describing a column from a ``DataFrame`` by accessing it as
 |      an attribute.
 |      
 |      >>> df.numeric.describe()
 |      count    3.0
 |      mean     2.0
 |      std      1.0
 |      min      1.0
 |      25%      1.5
 |      50%      2.0
 |      75%      2.5
 |      max      3.0
 |      Name: numeric, dtype: float64
 |      
 |      Including only numeric columns in a ``DataFrame`` description.
 |      
 |      >>> df.describe(include=[np.number])
 |             numeric
 |      count      3.0
 |      mean       2.0
 |      std        1.0
 |      min        1.0
 |      25%        1.5
 |      50%        2.0
 |      75%        2.5
 |      max        3.0
 |      
 |      Including only string columns in a ``DataFrame`` description.
 |      
 |      >>> df.describe(include=[np.object])
 |             object
 |      count       3
 |      unique      3
 |      top         b
 |      freq        1
 |      
 |      Excluding numeric columns from a ``DataFrame`` description.
 |      
 |      >>> df.describe(exclude=[np.number])
 |             object
 |      count       3
 |      unique      3
 |      top         b
 |      freq        1
 |      
 |      Excluding object columns from a ``DataFrame`` description.
 |      
 |      >>> df.describe(exclude=[np.object])
 |             numeric
 |      count      3.0
 |      mean       2.0
 |      std        1.0
 |      min        1.0
 |      25%        1.5
 |      50%        2.0
 |      75%        2.5
 |      max        3.0
 |      
 |      See Also
 |      --------
 |      DataFrame.count
 |      DataFrame.max
 |      DataFrame.min
 |      DataFrame.mean
 |      DataFrame.std
 |      DataFrame.select_dtypes
 |  
 |  drop(self, labels, axis=0, level=None, inplace=False, errors='raise')
 |      Return new object with labels in requested axis removed.
 |      
 |      Parameters
 |      ----------
 |      labels : single label or list-like
 |      axis : int or axis name
 |      level : int or level name, default None
 |          For MultiIndex
 |      inplace : bool, default False
 |          If True, do operation inplace and return None.
 |      errors : {'ignore', 'raise'}, default 'raise'
 |          If 'ignore', suppress error and existing labels are dropped.
 |      
 |          .. versionadded:: 0.16.1
 |      
 |      Returns
 |      -------
 |      dropped : type of caller
 |  
 |  equals(self, other)
 |      Determines if two NDFrame objects contain the same elements. NaNs in
 |      the same location are considered equal.
 |  
 |  ffill(self, axis=None, inplace=False, limit=None, downcast=None)
 |      Synonym for :meth:`DataFrame.fillna(method='ffill') <DataFrame.fillna>`
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Subset rows or columns of dataframe according to labels in
 |      the specified index.
 |      
 |      Note that this routine does not filter a dataframe on its
 |      contents. The filter is applied to the labels of the index.
 |      
 |      Parameters
 |      ----------
 |      items : list-like
 |          List of info axis to restrict to (must not all be present)
 |      like : string
 |          Keep info axis where "arg in col == True"
 |      regex : string (regular expression)
 |          Keep info axis with re.search(regex, col) == True
 |      axis : int or string axis name
 |          The axis to filter on.  By default this is the info axis,
 |          'index' for Series, 'columns' for DataFrame
 |      
 |      Returns
 |      -------
 |      same type as input object
 |      
 |      Examples
 |      --------
 |      >>> df
 |      one  two  three
 |      mouse     1    2      3
 |      rabbit    4    5      6
 |      
 |      >>> # select columns by name
 |      >>> df.filter(items=['one', 'three'])
 |      one  three
 |      mouse     1      3
 |      rabbit    4      6
 |      
 |      >>> # select columns by regular expression
 |      >>> df.filter(regex='e$', axis=1)
 |      one  three
 |      mouse     1      3
 |      rabbit    4      6
 |      
 |      >>> # select rows containing 'bbi'
 |      >>> df.filter(like='bbi', axis=0)
 |      one  two  three
 |      rabbit    4    5      6
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.select
 |      
 |      Notes
 |      -----
 |      The ``items``, ``like``, and ``regex`` parameters are
 |      enforced to be mutually exclusive.
 |      
 |      ``axis`` defaults to the info axis that is used when indexing
 |      with ``[]``.
 |  
 |  first(self, offset)
 |      Convenience method for subsetting initial periods of time series data
 |      based on a date offset.
 |      
 |      Parameters
 |      ----------
 |      offset : string, DateOffset, dateutil.relativedelta
 |      
 |      Examples
 |      --------
 |      ts.first('10D') -> First 10 days
 |      
 |      Returns
 |      -------
 |      subset : type of caller
 |  
 |  get(self, key, default=None)
 |      Get item from object for given key (DataFrame column, Panel slice,
 |      etc.). Returns default value if not found.
 |      
 |      Parameters
 |      ----------
 |      key : object
 |      
 |      Returns
 |      -------
 |      value : type of items contained in object
 |  
 |  get_dtype_counts(self)
 |      Return the counts of dtypes in this object.
 |  
 |  get_ftype_counts(self)
 |      Return the counts of ftypes in this object.
 |  
 |  groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
 |      Group series using mapper (dict or key function, apply given function
 |      to group, return result as series) or by a series of columns.
 |      
 |      Parameters
 |      ----------
 |      by : mapping, function, str, or iterable
 |          Used to determine the groups for the groupby.
 |          If ``by`` is a function, it's called on each value of the object's
 |          index. If a dict or Series is passed, the Series or dict VALUES
 |          will be used to determine the groups (the Series' values are first
 |          aligned; see ``.align()`` method). If an ndarray is passed, the
 |          values are used as-is determine the groups. A str or list of strs
 |          may be passed to group by the columns in ``self``
 |      axis : int, default 0
 |      level : int, level name, or sequence of such, default None
 |          If the axis is a MultiIndex (hierarchical), group by a particular
 |          level or levels
 |      as_index : boolean, default True
 |          For aggregated output, return object with group labels as the
 |          index. Only relevant for DataFrame input. as_index=False is
 |          effectively "SQL-style" grouped output
 |      sort : boolean, default True
 |          Sort group keys. Get better performance by turning this off.
 |          Note this does not influence the order of observations within each
 |          group.  groupby preserves the order of rows within each group.
 |      group_keys : boolean, default True
 |          When calling apply, add group keys to index to identify pieces
 |      squeeze : boolean, default False
 |          reduce the dimensionality of the return type if possible,
 |          otherwise return a consistent type
 |      
 |      Examples
 |      --------
 |      DataFrame results
 |      
 |      >>> data.groupby(func, axis=0).mean()
 |      >>> data.groupby(['col1', 'col2'])['col3'].mean()
 |      
 |      DataFrame with hierarchical index
 |      
 |      >>> data.groupby(['col1', 'col2']).mean()
 |      
 |      Returns
 |      -------
 |      GroupBy object
 |  
 |  head(self, n=5)
 |      Returns first n rows
 |  
 |  interpolate(self, method='linear', axis=0, limit=None, inplace=False, limit_direction='forward', downcast=None, **kwargs)
 |      Interpolate values according to different methods.
 |      
 |      Please note that only ``method='linear'`` is supported for
 |      DataFrames/Series with a MultiIndex.
 |      
 |      Parameters
 |      ----------
 |      method : {'linear', 'time', 'index', 'values', 'nearest', 'zero',
 |                'slinear', 'quadratic', 'cubic', 'barycentric', 'krogh',
 |                'polynomial', 'spline', 'piecewise_polynomial',
 |                'from_derivatives', 'pchip', 'akima'}
 |      
 |          * 'linear': ignore the index and treat the values as equally
 |            spaced. This is the only method supported on MultiIndexes.
 |            default
 |          * 'time': interpolation works on daily and higher resolution
 |            data to interpolate given length of interval
 |          * 'index', 'values': use the actual numerical values of the index
 |          * 'nearest', 'zero', 'slinear', 'quadratic', 'cubic',
 |            'barycentric', 'polynomial' is passed to
 |            ``scipy.interpolate.interp1d``. Both 'polynomial' and 'spline'
 |            require that you also specify an `order` (int),
 |            e.g. df.interpolate(method='polynomial', order=4).
 |            These use the actual numerical values of the index.
 |          * 'krogh', 'piecewise_polynomial', 'spline', 'pchip' and 'akima'
 |            are all wrappers around the scipy interpolation methods of
 |            similar names. These use the actual numerical values of the
 |            index. For more information on their behavior, see the
 |            `scipy documentation
 |            <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__
 |            and `tutorial documentation
 |            <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__
 |          * 'from_derivatives' refers to BPoly.from_derivatives which
 |            replaces 'piecewise_polynomial' interpolation method in
 |            scipy 0.18
 |      
 |          .. versionadded:: 0.18.1
 |      
 |             Added support for the 'akima' method
 |             Added interpolate method 'from_derivatives' which replaces
 |             'piecewise_polynomial' in scipy 0.18; backwards-compatible with
 |             scipy < 0.18
 |      
 |      axis : {0, 1}, default 0
 |          * 0: fill column-by-column
 |          * 1: fill row-by-row
 |      limit : int, default None.
 |          Maximum number of consecutive NaNs to fill. Must be greater than 0.
 |      limit_direction : {'forward', 'backward', 'both'}, default 'forward'
 |          If limit is specified, consecutive NaNs will be filled in this
 |          direction.
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      inplace : bool, default False
 |          Update the NDFrame in place if possible.
 |      downcast : optional, 'infer' or None, defaults to None
 |          Downcast dtypes if possible.
 |      kwargs : keyword arguments to pass on to the interpolating function.
 |      
 |      Returns
 |      -------
 |      Series or DataFrame of same shape interpolated at the NaNs
 |      
 |      See Also
 |      --------
 |      reindex, replace, fillna
 |      
 |      Examples
 |      --------
 |      
 |      Filling in NaNs
 |      
 |      >>> s = pd.Series([0, 1, np.nan, 3])
 |      >>> s.interpolate()
 |      0    0
 |      1    1
 |      2    2
 |      3    3
 |      dtype: float64
 |  
 |  isnull(self)
 |      Return a boolean same-sized object indicating if the values are null.
 |      
 |      See Also
 |      --------
 |      notnull : boolean inverse of isnull
 |  
 |  last(self, offset)
 |      Convenience method for subsetting final periods of time series data
 |      based on a date offset.
 |      
 |      Parameters
 |      ----------
 |      offset : string, DateOffset, dateutil.relativedelta
 |      
 |      Examples
 |      --------
 |      ts.last('5M') -> Last 5 months
 |      
 |      Returns
 |      -------
 |      subset : type of caller
 |  
 |  mask(self, cond, other=nan, inplace=False, axis=None, level=None, try_cast=False, raise_on_error=True)
 |      Return an object of same shape as self and whose corresponding
 |      entries are from self where cond is False and otherwise are from
 |      other.
 |      
 |      Parameters
 |      ----------
 |      cond : boolean NDFrame, array-like, or callable
 |          If cond is callable, it is computed on the NDFrame and
 |          should return boolean NDFrame or array. The callable must
 |          not change input NDFrame (though pandas doesn't check it).
 |      
 |          .. versionadded:: 0.18.1
 |              A callable can be used as cond.
 |      
 |      other : scalar, NDFrame, or callable
 |          If other is callable, it is computed on the NDFrame and
 |          should return scalar or NDFrame. The callable must not
 |          change input NDFrame (though pandas doesn't check it).
 |      
 |          .. versionadded:: 0.18.1
 |              A callable can be used as other.
 |      
 |      inplace : boolean, default False
 |          Whether to perform the operation in place on the data
 |      axis : alignment axis if needed, default None
 |      level : alignment level if needed, default None
 |      try_cast : boolean, default False
 |          try to cast the result back to the input type (if possible),
 |      raise_on_error : boolean, default True
 |          Whether to raise on invalid data types (e.g. trying to where on
 |          strings)
 |      
 |      Returns
 |      -------
 |      wh : same type as caller
 |      
 |      Notes
 |      -----
 |      The mask method is an application of the if-then idiom. For each
 |      element in the calling DataFrame, if ``cond`` is ``False`` the
 |      element is used; otherwise the corresponding element from the DataFrame
 |      ``other`` is used.
 |      
 |      The signature for :func:`DataFrame.where` differs from
 |      :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to
 |      ``np.where(m, df1, df2)``.
 |      
 |      For further details and examples see the ``mask`` documentation in
 |      :ref:`indexing <indexing.where_mask>`.
 |      
 |      Examples
 |      --------
 |      >>> s = pd.Series(range(5))
 |      >>> s.where(s > 0)
 |      0    NaN
 |      1    1.0
 |      2    2.0
 |      3    3.0
 |      4    4.0
 |      
 |      >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])
 |      >>> m = df % 3 == 0
 |      >>> df.where(m, -df)
 |         A  B
 |      0  0 -1
 |      1 -2  3
 |      2 -4 -5
 |      3  6 -7
 |      4 -8  9
 |      >>> df.where(m, -df) == np.where(m, df, -df)
 |            A     B
 |      0  True  True
 |      1  True  True
 |      2  True  True
 |      3  True  True
 |      4  True  True
 |      >>> df.where(m, -df) == df.mask(~m, -df)
 |            A     B
 |      0  True  True
 |      1  True  True
 |      2  True  True
 |      3  True  True
 |      4  True  True
 |      
 |      See Also
 |      --------
 |      :func:`DataFrame.where`
 |  
 |  notnull(self)
 |      Return a boolean same-sized object indicating if the values are
 |      not null.
 |      
 |      See Also
 |      --------
 |      isnull : boolean inverse of notnull
 |  
 |  pct_change(self, periods=1, fill_method='pad', limit=None, freq=None, **kwargs)
 |      Percent change over given number of periods.
 |      
 |      Parameters
 |      ----------
 |      periods : int, default 1
 |          Periods to shift for forming percent change
 |      fill_method : str, default 'pad'
 |          How to handle NAs before computing percent changes
 |      limit : int, default None
 |          The number of consecutive NAs to fill before stopping
 |      freq : DateOffset, timedelta, or offset alias string, optional
 |          Increment to use from time series API (e.g. 'M' or BDay())
 |      
 |      Returns
 |      -------
 |      chg : NDFrame
 |      
 |      Notes
 |      -----
 |      
 |      By default, the percentage change is calculated along the stat
 |      axis: 0, or ``Index``, for ``DataFrame`` and 1, or ``minor`` for
 |      ``Panel``. You can change this with the ``axis`` keyword argument.
 |  
 |  pipe(self, func, *args, **kwargs)
 |      Apply func(self, \*args, \*\*kwargs)
 |      
 |      .. versionadded:: 0.16.2
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          function to apply to the NDFrame.
 |          ``args``, and ``kwargs`` are passed into ``func``.
 |          Alternatively a ``(callable, data_keyword)`` tuple where
 |          ``data_keyword`` is a string indicating the keyword of
 |          ``callable`` that expects the NDFrame.
 |      args : positional arguments passed into ``func``.
 |      kwargs : a dictionary of keyword arguments passed into ``func``.
 |      
 |      Returns
 |      -------
 |      object : the return type of ``func``.
 |      
 |      Notes
 |      -----
 |      
 |      Use ``.pipe`` when chaining together functions that expect
 |      on Series or DataFrames. Instead of writing
 |      
 |      >>> f(g(h(df), arg1=a), arg2=b, arg3=c)
 |      
 |      You can write
 |      
 |      >>> (df.pipe(h)
 |      ...    .pipe(g, arg1=a)
 |      ...    .pipe(f, arg2=b, arg3=c)
 |      ... )
 |      
 |      If you have a function that takes the data as (say) the second
 |      argument, pass a tuple indicating which keyword expects the
 |      data. For example, suppose ``f`` takes its data as ``arg2``:
 |      
 |      >>> (df.pipe(h)
 |      ...    .pipe(g, arg1=a)
 |      ...    .pipe((f, 'arg2'), arg1=a, arg3=c)
 |      ...  )
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.apply
 |      pandas.DataFrame.applymap
 |      pandas.Series.map
 |  
 |  pop(self, item)
 |      Return item and drop from frame. Raise KeyError if not found.
 |  
 |  rank(self, axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)
 |      Compute numerical data ranks (1 through n) along axis. Equal values are
 |      assigned a rank that is the average of the ranks of those values
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          index to direct ranking
 |      method : {'average', 'min', 'max', 'first', 'dense'}
 |          * average: average rank of group
 |          * min: lowest rank in group
 |          * max: highest rank in group
 |          * first: ranks assigned in order they appear in the array
 |          * dense: like 'min', but rank always increases by 1 between groups
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. Valid only for DataFrame or
 |          Panel objects
 |      na_option : {'keep', 'top', 'bottom'}
 |          * keep: leave NA values where they are
 |          * top: smallest rank if ascending
 |          * bottom: smallest rank if descending
 |      ascending : boolean, default True
 |          False for ranks by high (1) to low (N)
 |      pct : boolean, default False
 |          Computes percentage rank of data
 |      
 |      Returns
 |      -------
 |      ranks : same type as caller
 |  
 |  reindex_like(self, other, method=None, copy=True, limit=None, tolerance=None)
 |      Return an object with matching indices to myself.
 |      
 |      Parameters
 |      ----------
 |      other : Object
 |      method : string or None
 |      copy : boolean, default True
 |      limit : int, default None
 |          Maximum number of consecutive labels to fill for inexact matches.
 |      tolerance : optional
 |          Maximum distance between labels of the other object and this
 |          object for inexact matches.
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Notes
 |      -----
 |      Like calling s.reindex(index=other.index, columns=other.columns,
 |                             method=...)
 |      
 |      Returns
 |      -------
 |      reindexed : same as input
 |  
 |  rename_axis(self, mapper, axis=0, copy=True, inplace=False)
 |      Alter index and / or columns using input function or functions.
 |      A scalar or list-like for ``mapper`` will alter the ``Index.name``
 |      or ``MultiIndex.names`` attribute.
 |      A function or dict for ``mapper`` will alter the labels.
 |      Function / dict values must be unique (1-to-1). Labels not contained in
 |      a dict / Series will be left as-is.
 |      
 |      Parameters
 |      ----------
 |      mapper : scalar, list-like, dict-like or function, optional
 |      axis : int or string, default 0
 |      copy : boolean, default True
 |          Also copy underlying data
 |      inplace : boolean, default False
 |      
 |      Returns
 |      -------
 |      renamed : type of caller
 |      
 |      See Also
 |      --------
 |      pandas.NDFrame.rename
 |      pandas.Index.rename
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
 |      >>> df.rename_axis("foo")  # scalar, alters df.index.name
 |           A  B
 |      foo
 |      0    1  4
 |      1    2  5
 |      2    3  6
 |      >>> df.rename_axis(lambda x: 2 * x)  # function: alters labels
 |         A  B
 |      0  1  4
 |      2  2  5
 |      4  3  6
 |      >>> df.rename_axis({"A": "ehh", "C": "see"}, axis="columns")  # mapping
 |         ehh  B
 |      0    1  4
 |      1    2  5
 |      2    3  6
 |  
 |  replace(self, to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad', axis=None)
 |      Replace values given in 'to_replace' with 'value'.
 |      
 |      Parameters
 |      ----------
 |      to_replace : str, regex, list, dict, Series, numeric, or None
 |      
 |          * str or regex:
 |      
 |              - str: string exactly matching `to_replace` will be replaced
 |                with `value`
 |              - regex: regexs matching `to_replace` will be replaced with
 |                `value`
 |      
 |          * list of str, regex, or numeric:
 |      
 |              - First, if `to_replace` and `value` are both lists, they
 |                **must** be the same length.
 |              - Second, if ``regex=True`` then all of the strings in **both**
 |                lists will be interpreted as regexs otherwise they will match
 |                directly. This doesn't matter much for `value` since there
 |                are only a few possible substitution regexes you can use.
 |              - str and regex rules apply as above.
 |      
 |          * dict:
 |      
 |              - Nested dictionaries, e.g., {'a': {'b': nan}}, are read as
 |                follows: look in column 'a' for the value 'b' and replace it
 |                with nan. You can nest regular expressions as well. Note that
 |                column names (the top-level dictionary keys in a nested
 |                dictionary) **cannot** be regular expressions.
 |              - Keys map to column names and values map to substitution
 |                values. You can treat this as a special case of passing two
 |                lists except that you are specifying the column to search in.
 |      
 |          * None:
 |      
 |              - This means that the ``regex`` argument must be a string,
 |                compiled regular expression, or list, dict, ndarray or Series
 |                of such elements. If `value` is also ``None`` then this
 |                **must** be a nested dictionary or ``Series``.
 |      
 |          See the examples section for examples of each of these.
 |      value : scalar, dict, list, str, regex, default None
 |          Value to use to fill holes (e.g. 0), alternately a dict of values
 |          specifying which value to use for each column (columns not in the
 |          dict will not be filled). Regular expressions, strings and lists or
 |          dicts of such objects are also allowed.
 |      inplace : boolean, default False
 |          If True, in place. Note: this will modify any
 |          other views on this object (e.g. a column form a DataFrame).
 |          Returns the caller if this is True.
 |      limit : int, default None
 |          Maximum size gap to forward or backward fill
 |      regex : bool or same types as `to_replace`, default False
 |          Whether to interpret `to_replace` and/or `value` as regular
 |          expressions. If this is ``True`` then `to_replace` *must* be a
 |          string. Otherwise, `to_replace` must be ``None`` because this
 |          parameter will be interpreted as a regular expression or a list,
 |          dict, or array of regular expressions.
 |      method : string, optional, {'pad', 'ffill', 'bfill'}
 |          The method to use when for replacement, when ``to_replace`` is a
 |          ``list``.
 |      
 |      See Also
 |      --------
 |      NDFrame.reindex
 |      NDFrame.asfreq
 |      NDFrame.fillna
 |      
 |      Returns
 |      -------
 |      filled : NDFrame
 |      
 |      Raises
 |      ------
 |      AssertionError
 |          * If `regex` is not a ``bool`` and `to_replace` is not ``None``.
 |      TypeError
 |          * If `to_replace` is a ``dict`` and `value` is not a ``list``,
 |            ``dict``, ``ndarray``, or ``Series``
 |          * If `to_replace` is ``None`` and `regex` is not compilable into a
 |            regular expression or is a list, dict, ndarray, or Series.
 |      ValueError
 |          * If `to_replace` and `value` are ``list`` s or ``ndarray`` s, but
 |            they are not the same length.
 |      
 |      Notes
 |      -----
 |      * Regex substitution is performed under the hood with ``re.sub``. The
 |        rules for substitution for ``re.sub`` are the same.
 |      * Regular expressions will only substitute on strings, meaning you
 |        cannot provide, for example, a regular expression matching floating
 |        point numbers and expect the columns in your frame that have a
 |        numeric dtype to be matched. However, if those floating point numbers
 |        *are* strings, then you can do this.
 |      * This method has *a lot* of options. You are encouraged to experiment
 |        and play with this method to gain intuition about how it works.
 |  
 |  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)
 |      Convenience method for frequency conversion and resampling of time
 |      series.  Object must have a datetime-like index (DatetimeIndex,
 |      PeriodIndex, or TimedeltaIndex), or pass datetime-like values
 |      to the on or level keyword.
 |      
 |      Parameters
 |      ----------
 |      rule : string
 |          the offset string or object representing target conversion
 |      axis : int, optional, default 0
 |      closed : {'right', 'left'}
 |          Which side of bin interval is closed
 |      label : {'right', 'left'}
 |          Which bin edge label to label bucket with
 |      convention : {'start', 'end', 's', 'e'}
 |      loffset : timedelta
 |          Adjust the resampled time labels
 |      base : int, default 0
 |          For frequencies that evenly subdivide 1 day, the "origin" of the
 |          aggregated intervals. For example, for '5min' frequency, base could
 |          range from 0 through 4. Defaults to 0
 |      on : string, optional
 |          For a DataFrame, column to use instead of index for resampling.
 |          Column must be datetime-like.
 |      
 |          .. versionadded:: 0.19.0
 |      
 |      level : string or int, optional
 |          For a MultiIndex, level (name or number) to use for
 |          resampling.  Level must be datetime-like.
 |      
 |          .. versionadded:: 0.19.0
 |      
 |      Notes
 |      -----
 |      To learn more about the offset strings, please see `this link
 |      <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__.
 |      
 |      Examples
 |      --------
 |      
 |      Start by creating a series with 9 one minute timestamps.
 |      
 |      >>> index = pd.date_range('1/1/2000', periods=9, freq='T')
 |      >>> series = pd.Series(range(9), index=index)
 |      >>> series
 |      2000-01-01 00:00:00    0
 |      2000-01-01 00:01:00    1
 |      2000-01-01 00:02:00    2
 |      2000-01-01 00:03:00    3
 |      2000-01-01 00:04:00    4
 |      2000-01-01 00:05:00    5
 |      2000-01-01 00:06:00    6
 |      2000-01-01 00:07:00    7
 |      2000-01-01 00:08:00    8
 |      Freq: T, dtype: int64
 |      
 |      Downsample the series into 3 minute bins and sum the values
 |      of the timestamps falling into a bin.
 |      
 |      >>> series.resample('3T').sum()
 |      2000-01-01 00:00:00     3
 |      2000-01-01 00:03:00    12
 |      2000-01-01 00:06:00    21
 |      Freq: 3T, dtype: int64
 |      
 |      Downsample the series into 3 minute bins as above, but label each
 |      bin using the right edge instead of the left. Please note that the
 |      value in the bucket used as the label is not included in the bucket,
 |      which it labels. For example, in the original series the
 |      bucket ``2000-01-01 00:03:00`` contains the value 3, but the summed
 |      value in the resampled bucket with the label``2000-01-01 00:03:00``
 |      does not include 3 (if it did, the summed value would be 6, not 3).
 |      To include this value close the right side of the bin interval as
 |      illustrated in the example below this one.
 |      
 |      >>> series.resample('3T', label='right').sum()
 |      2000-01-01 00:03:00     3
 |      2000-01-01 00:06:00    12
 |      2000-01-01 00:09:00    21
 |      Freq: 3T, dtype: int64
 |      
 |      Downsample the series into 3 minute bins as above, but close the right
 |      side of the bin interval.
 |      
 |      >>> series.resample('3T', label='right', closed='right').sum()
 |      2000-01-01 00:00:00     0
 |      2000-01-01 00:03:00     6
 |      2000-01-01 00:06:00    15
 |      2000-01-01 00:09:00    15
 |      Freq: 3T, dtype: int64
 |      
 |      Upsample the series into 30 second bins.
 |      
 |      >>> series.resample('30S').asfreq()[0:5] #select first 5 rows
 |      2000-01-01 00:00:00   0.0
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00   1.0
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00   2.0
 |      Freq: 30S, dtype: float64
 |      
 |      Upsample the series into 30 second bins and fill the ``NaN``
 |      values using the ``pad`` method.
 |      
 |      >>> series.resample('30S').pad()[0:5]
 |      2000-01-01 00:00:00    0
 |      2000-01-01 00:00:30    0
 |      2000-01-01 00:01:00    1
 |      2000-01-01 00:01:30    1
 |      2000-01-01 00:02:00    2
 |      Freq: 30S, dtype: int64
 |      
 |      Upsample the series into 30 second bins and fill the
 |      ``NaN`` values using the ``bfill`` method.
 |      
 |      >>> series.resample('30S').bfill()[0:5]
 |      2000-01-01 00:00:00    0
 |      2000-01-01 00:00:30    1
 |      2000-01-01 00:01:00    1
 |      2000-01-01 00:01:30    2
 |      2000-01-01 00:02:00    2
 |      Freq: 30S, dtype: int64
 |      
 |      Pass a custom function via ``apply``
 |      
 |      >>> def custom_resampler(array_like):
 |      ...     return np.sum(array_like)+5
 |      
 |      >>> series.resample('3T').apply(custom_resampler)
 |      2000-01-01 00:00:00     8
 |      2000-01-01 00:03:00    17
 |      2000-01-01 00:06:00    26
 |      Freq: 3T, dtype: int64
 |      
 |      For DataFrame objects, the keyword ``on`` can be used to specify the
 |      column instead of the index for resampling.
 |      
 |      >>> df = pd.DataFrame(data=9*[range(4)], columns=['a', 'b', 'c', 'd'])
 |      >>> df['time'] = pd.date_range('1/1/2000', periods=9, freq='T')
 |      >>> df.resample('3T', on='time').sum()
 |                           a  b  c  d
 |      time
 |      2000-01-01 00:00:00  0  3  6  9
 |      2000-01-01 00:03:00  0  3  6  9
 |      2000-01-01 00:06:00  0  3  6  9
 |      
 |      For a DataFrame with MultiIndex, the keyword ``level`` can be used to
 |      specify on level the resampling needs to take place.
 |      
 |      >>> time = pd.date_range('1/1/2000', periods=5, freq='T')
 |      >>> df2 = pd.DataFrame(data=10*[range(4)],
 |                             columns=['a', 'b', 'c', 'd'],
 |                             index=pd.MultiIndex.from_product([time, [1, 2]])
 |                             )
 |      >>> df2.resample('3T', level=0).sum()
 |                           a  b   c   d
 |      2000-01-01 00:00:00  0  6  12  18
 |      2000-01-01 00:03:00  0  4   8  12
 |  
 |  sample(self, n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)
 |      Returns a random sample of items from an axis of object.
 |      
 |      .. versionadded:: 0.16.1
 |      
 |      Parameters
 |      ----------
 |      n : int, optional
 |          Number of items from axis to return. Cannot be used with `frac`.
 |          Default = 1 if `frac` = None.
 |      frac : float, optional
 |          Fraction of axis items to return. Cannot be used with `n`.
 |      replace : boolean, optional
 |          Sample with or without replacement. Default = False.
 |      weights : str or ndarray-like, optional
 |          Default 'None' results in equal probability weighting.
 |          If passed a Series, will align with target object on index. Index
 |          values in weights not found in sampled object will be ignored and
 |          index values in sampled object not in weights will be assigned
 |          weights of zero.
 |          If called on a DataFrame, will accept the name of a column
 |          when axis = 0.
 |          Unless weights are a Series, weights must be same length as axis
 |          being sampled.
 |          If weights do not sum to 1, they will be normalized to sum to 1.
 |          Missing values in the weights column will be treated as zero.
 |          inf and -inf values not allowed.
 |      random_state : int or numpy.random.RandomState, optional
 |          Seed for the random number generator (if int), or numpy RandomState
 |          object.
 |      axis : int or string, optional
 |          Axis to sample. Accepts axis number or name. Default is stat axis
 |          for given data type (0 for Series and DataFrames, 1 for Panels).
 |      
 |      Returns
 |      -------
 |      A new object of same type as caller.
 |      
 |      Examples
 |      --------
 |      
 |      Generate an example ``Series`` and ``DataFrame``:
 |      
 |      >>> s = pd.Series(np.random.randn(50))
 |      >>> s.head()
 |      0   -0.038497
 |      1    1.820773
 |      2   -0.972766
 |      3   -1.598270
 |      4   -1.095526
 |      dtype: float64
 |      >>> df = pd.DataFrame(np.random.randn(50, 4), columns=list('ABCD'))
 |      >>> df.head()
 |                A         B         C         D
 |      0  0.016443 -2.318952 -0.566372 -1.028078
 |      1 -1.051921  0.438836  0.658280 -0.175797
 |      2 -1.243569 -0.364626 -0.215065  0.057736
 |      3  1.768216  0.404512 -0.385604 -1.457834
 |      4  1.072446 -1.137172  0.314194 -0.046661
 |      
 |      Next extract a random sample from both of these objects...
 |      
 |      3 random elements from the ``Series``:
 |      
 |      >>> s.sample(n=3)
 |      27   -0.994689
 |      55   -1.049016
 |      67   -0.224565
 |      dtype: float64
 |      
 |      And a random 10% of the ``DataFrame`` with replacement:
 |      
 |      >>> df.sample(frac=0.1, replace=True)
 |                 A         B         C         D
 |      35  1.981780  0.142106  1.817165 -0.290805
 |      49 -1.336199 -0.448634 -0.789640  0.217116
 |      40  0.823173 -0.078816  1.009536  1.015108
 |      15  1.421154 -0.055301 -1.922594 -0.019696
 |      6  -0.148339  0.832938  1.787600 -1.383767
 |  
 |  select(self, crit, axis=0)
 |      Return data corresponding to axis labels matching criteria
 |      
 |      Parameters
 |      ----------
 |      crit : function
 |          To be called on each index (label). Should return True or False
 |      axis : int
 |      
 |      Returns
 |      -------
 |      selection : type of caller
 |  
 |  set_axis(self, axis, labels)
 |      public verson of axis assignment
 |  
 |  slice_shift(self, periods=1, axis=0)
 |      Equivalent to `shift` without copying data. The shifted data will
 |      not include the dropped periods and the shifted axis will be smaller
 |      than the original.
 |      
 |      Parameters
 |      ----------
 |      periods : int
 |          Number of periods to move, can be positive or negative
 |      
 |      Notes
 |      -----
 |      While the `slice_shift` is faster than `shift`, you may pay for it
 |      later during alignment.
 |      
 |      Returns
 |      -------
 |      shifted : same type as caller
 |  
 |  squeeze(self, axis=None)
 |      Squeeze length 1 dimensions.
 |      
 |      Parameters
 |      ----------
 |      axis : None, integer or string axis name, optional
 |          The axis to squeeze if 1-sized.
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      Returns
 |      -------
 |      scalar if 1-sized, else original object
 |  
 |  swapaxes(self, axis1, axis2, copy=True)
 |      Interchange axes and swap values axes appropriately
 |      
 |      Returns
 |      -------
 |      y : same as input
 |  
 |  tail(self, n=5)
 |      Returns last n rows
 |  
 |  to_clipboard(self, excel=None, sep=None, **kwargs)
 |      Attempt to write text representation of object to the system clipboard
 |      This can be pasted into Excel, for example.
 |      
 |      Parameters
 |      ----------
 |      excel : boolean, defaults to True
 |              if True, use the provided separator, writing in a csv
 |              format for allowing easy pasting into excel.
 |              if False, write a string representation of the object
 |              to the clipboard
 |      sep : optional, defaults to tab
 |      other keywords are passed to to_csv
 |      
 |      Notes
 |      -----
 |      Requirements for your platform
 |        - Linux: xclip, or xsel (with gtk or PyQt4 modules)
 |        - Windows: none
 |        - OS X: none
 |  
 |  to_dense(self)
 |      Return dense representation of NDFrame (as opposed to sparse)
 |  
 |  to_hdf(self, path_or_buf, key, **kwargs)
 |      Write the contained data to an HDF5 file using HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          identifier for the group in the store
 |      mode : optional, {'a', 'w', 'r+'}, default 'a'
 |      
 |        ``'w'``
 |            Write; a new file is created (an existing file with the same
 |            name would be deleted).
 |        ``'a'``
 |            Append; an existing file is opened for reading and writing,
 |            and if the file does not exist it is created.
 |        ``'r+'``
 |            It is similar to ``'a'``, but the file must already exist.
 |      format : 'fixed(f)|table(t)', default is 'fixed'
 |          fixed(f) : Fixed format
 |                     Fast writing/reading. Not-appendable, nor searchable
 |          table(t) : Table format
 |                     Write as a PyTables Table structure which may perform
 |                     worse but allow more flexible operations like searching
 |                     / selecting subsets of the data
 |      append : boolean, default False
 |          For Table formats, append the input data to the existing
 |      data_columns :  list of columns, or True, default None
 |          List of columns to create as indexed data columns for on-disk
 |          queries, or True to use all columns. By default only the axes
 |          of the object are indexed. See `here
 |          <http://pandas.pydata.org/pandas-docs/stable/io.html#query-via-data-columns>`__.
 |      
 |          Applicable only to format='table'.
 |      complevel : int, 0-9, default 0
 |          Specifies a compression level for data.
 |          A value of 0 disables compression.
 |      complib : {'zlib', 'lzo', 'bzip2', 'blosc', None}, default None
 |          Specifies the compression library to be used.
 |          As of v0.20.2 these additional compressors for Blosc are supported
 |          (default if no compressor specified: 'blosc:blosclz'):
 |          {'blosc:blosclz', 'blosc:lz4', 'blosc:lz4hc', 'blosc:snappy',
 |           'blosc:zlib', 'blosc:zstd'}.
 |          Specifying a compression library which is not available issues
 |          a ValueError.
 |      fletcher32 : bool, default False
 |          If applying compression use the fletcher32 checksum
 |      dropna : boolean, default False.
 |          If true, ALL nan rows will not be written to store.
 |  
 |  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)
 |      Convert the object to a JSON string.
 |      
 |      Note NaN's and None will be converted to null and datetime objects
 |      will be converted to UNIX timestamps.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path or buffer to write the result string
 |          if this is None, return a StringIO of the converted string
 |      orient : string
 |      
 |          * Series
 |      
 |            - default is 'index'
 |            - allowed values are: {'split','records','index'}
 |      
 |          * DataFrame
 |      
 |            - default is 'columns'
 |            - allowed values are:
 |              {'split','records','index','columns','values'}
 |      
 |          * The format of the JSON string
 |      
 |            - split : dict like
 |              {index -> [index], columns -> [columns], data -> [values]}
 |            - records : list like
 |              [{column -> value}, ... , {column -> value}]
 |            - index : dict like {index -> {column -> value}}
 |            - columns : dict like {column -> {index -> value}}
 |            - values : just the values array
 |            - table : dict like {'schema': {schema}, 'data': {data}}
 |              describing the data, and the data component is
 |              like ``orient='records'``.
 |      
 |              .. versionchanged:: 0.20.0
 |      
 |      date_format : {None, 'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso` = ISO8601. The default depends on the `orient`. For
 |          `orient='table'`, the default is `'iso'`. For all other orients,
 |          the default is `'epoch'`.
 |      double_precision : The number of decimal places to use when encoding
 |          floating point values, default 10.
 |      force_ascii : force encoded string to be ASCII, default True.
 |      date_unit : string, default 'ms' (milliseconds)
 |          The time unit to encode to, governs timestamp and ISO8601
 |          precision.  One of 's', 'ms', 'us', 'ns' for second, millisecond,
 |          microsecond, and nanosecond respectively.
 |      default_handler : callable, default None
 |          Handler to call if object cannot otherwise be converted to a
 |          suitable format for JSON. Should receive a single argument which is
 |          the object to convert and return a serialisable object.
 |      lines : boolean, default False
 |          If 'orient' is 'records' write out line delimited json format. Will
 |          throw ValueError if incorrect 'orient' since others are not list
 |          like.
 |      
 |          .. versionadded:: 0.19.0
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |      
 |      See Also
 |      --------
 |      pd.read_json
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame([['a', 'b'], ['c', 'd']],
 |      ...                   index=['row 1', 'row 2'],
 |      ...                   columns=['col 1', 'col 2'])
 |      >>> df.to_json(orient='split')
 |      '{"columns":["col 1","col 2"],
 |        "index":["row 1","row 2"],
 |        "data":[["a","b"],["c","d"]]}'
 |      
 |      Encoding/decoding a Dataframe using ``'index'`` formatted JSON:
 |      
 |      >>> df.to_json(orient='index')
 |      '{"row 1":{"col 1":"a","col 2":"b"},"row 2":{"col 1":"c","col 2":"d"}}'
 |      
 |      Encoding/decoding a Dataframe using ``'records'`` formatted JSON.
 |      Note that index labels are not preserved with this encoding.
 |      
 |      >>> df.to_json(orient='records')
 |      '[{"col 1":"a","col 2":"b"},{"col 1":"c","col 2":"d"}]'
 |      
 |      Encoding with Table Schema
 |      
 |      >>> df.to_json(orient='table')
 |      '{"schema": {"fields": [{"name": "index", "type": "string"},
 |                              {"name": "col 1", "type": "string"},
 |                              {"name": "col 2", "type": "string"}],
 |                   "primaryKey": "index",
 |                   "pandas_version": "0.20.0"},
 |        "data": [{"index": "row 1", "col 1": "a", "col 2": "b"},
 |                 {"index": "row 2", "col 1": "c", "col 2": "d"}]}'
 |  
 |  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)
 |      Render an object to a tabular environment table. You can splice
 |      this into a LaTeX document. Requires \usepackage{booktabs}.
 |      
 |      .. versionchanged:: 0.20.2
 |         Added to Series
 |      
 |      `to_latex`-specific options:
 |      
 |      bold_rows : boolean, default False
 |          Make the row labels bold in the output
 |      column_format : str, default None
 |          The columns format as specified in `LaTeX table format
 |          <https://en.wikibooks.org/wiki/LaTeX/Tables>`__ e.g 'rcl' for 3
 |          columns
 |      longtable : boolean, default will be read from the pandas config module
 |          Default: False.
 |          Use a longtable environment instead of tabular. Requires adding
 |          a \usepackage{longtable} to your LaTeX preamble.
 |      escape : boolean, default will be read from the pandas config module
 |          Default: True.
 |          When set to False prevents from escaping latex special
 |          characters in column names.
 |      encoding : str, default None
 |          A string representing the encoding to use in the output file,
 |          defaults to 'ascii' on Python 2 and 'utf-8' on Python 3.
 |      decimal : string, default '.'
 |          Character recognized as decimal separator, e.g. ',' in Europe.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      multicolumn : boolean, default True
 |          Use \multicolumn to enhance MultiIndex columns.
 |          The default will be read from the config module.
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      multicolumn_format : str, default 'l'
 |          The alignment for multicolumns, similar to `column_format`
 |          The default will be read from the config module.
 |      
 |          .. versionadded:: 0.20.0
 |      
 |      multirow : boolean, default False
 |          Use \multirow to enhance MultiIndex rows.
 |          Requires adding a \usepackage{multirow} to your LaTeX preamble.
 |          Will print centered labels (instead of top-aligned)
 |          across the contained rows, separating groups via clines.
 |          The default will be read from the pandas config module.
 |      
 |          .. versionadded:: 0.20.0
 |  
 |  to_msgpack(self, path_or_buf=None, encoding='utf-8', **kwargs)
 |      msgpack (serialize) object to input file path
 |      
 |      THIS IS AN EXPERIMENTAL LIBRARY and the storage format
 |      may not be stable until a future release.
 |      
 |      Parameters
 |      ----------
 |      path : string File path, buffer-like, or None
 |          if None, return generated string
 |      append : boolean whether to append to an existing msgpack
 |          (default is False)
 |      compress : type of compressor (zlib or blosc), default to None (no
 |          compression)
 |  
 |  to_pickle(self, path, compression='infer')
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |      compression : {'infer', 'gzip', 'bz2', 'xz', None}, default 'infer'
 |          a string representing the compression to use in the output file
 |      
 |          .. versionadded:: 0.20.0
 |  
 |  to_sql(self, name, con, flavor=None, schema=None, if_exists='fail', index=True, index_label=None, chunksize=None, dtype=None)
 |      Write records stored in a DataFrame to a SQL database.
 |      
 |      Parameters
 |      ----------
 |      name : string
 |          Name of SQL table
 |      con : SQLAlchemy engine or DBAPI2 connection (legacy mode)
 |          Using SQLAlchemy makes it possible to use any DB supported by that
 |          library. If a DBAPI2 object, only sqlite3 is supported.
 |      flavor : 'sqlite', default None
 |          DEPRECATED: this parameter will be removed in a future version,
 |          as 'sqlite' is the only supported option if SQLAlchemy is not
 |          installed.
 |      schema : string, default None
 |          Specify the schema (if database flavor supports this). If None, use
 |          default schema.
 |      if_exists : {'fail', 'replace', 'append'}, default 'fail'
 |          - fail: If table exists, do nothing.
 |          - replace: If table exists, drop it, recreate it, and insert data.
 |          - append: If table exists, insert data. Create if does not exist.
 |      index : boolean, default True
 |          Write DataFrame index as a column.
 |      index_label : string or sequence, default None
 |          Column label for index column(s). If None is given (default) and
 |          `index` is True, then the index names are used.
 |          A sequence should be given if the DataFrame uses MultiIndex.
 |      chunksize : int, default None
 |          If not None, then rows will be written in batches of this size at a
 |          time.  If None, all rows will be written at once.
 |      dtype : dict of column name to SQL type, default None
 |          Optional specifying the datatype for columns. The SQL type should
 |          be a SQLAlchemy type, or a string for sqlite3 fallback connection.
 |  
 |  to_xarray(self)
 |      Return an xarray object from the pandas object.
 |      
 |      Returns
 |      -------
 |      a DataArray for a Series
 |      a Dataset for a DataFrame
 |      a DataArray for higher dims
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({'A' : [1, 1, 2],
 |                             'B' : ['foo', 'bar', 'foo'],
 |                             'C' : np.arange(4.,7)})
 |      >>> df
 |         A    B    C
 |      0  1  foo  4.0
 |      1  1  bar  5.0
 |      2  2  foo  6.0
 |      
 |      >>> df.to_xarray()
 |      <xarray.Dataset>
 |      Dimensions:  (index: 3)
 |      Coordinates:
 |        * index    (index) int64 0 1 2
 |      Data variables:
 |          A        (index) int64 1 1 2
 |          B        (index) object 'foo' 'bar' 'foo'
 |          C        (index) float64 4.0 5.0 6.0
 |      
 |      >>> df = pd.DataFrame({'A' : [1, 1, 2],
 |                             'B' : ['foo', 'bar', 'foo'],
 |                             'C' : np.arange(4.,7)}
 |                           ).set_index(['B','A'])
 |      >>> df
 |               C
 |      B   A
 |      foo 1  4.0
 |      bar 1  5.0
 |      foo 2  6.0
 |      
 |      >>> df.to_xarray()
 |      <xarray.Dataset>
 |      Dimensions:  (A: 2, B: 2)
 |      Coordinates:
 |        * B        (B) object 'bar' 'foo'
 |        * A        (A) int64 1 2
 |      Data variables:
 |          C        (B, A) float64 5.0 nan 4.0 6.0
 |      
 |      >>> p = pd.Panel(np.arange(24).reshape(4,3,2),
 |                       items=list('ABCD'),
 |                       major_axis=pd.date_range('20130101', periods=3),
 |                       minor_axis=['first', 'second'])
 |      >>> p
 |      <class 'pandas.core.panel.Panel'>
 |      Dimensions: 4 (items) x 3 (major_axis) x 2 (minor_axis)
 |      Items axis: A to D
 |      Major_axis axis: 2013-01-01 00:00:00 to 2013-01-03 00:00:00
 |      Minor_axis axis: first to second
 |      
 |      >>> p.to_xarray()
 |      <xarray.DataArray (items: 4, major_axis: 3, minor_axis: 2)>
 |      array([[[ 0,  1],
 |              [ 2,  3],
 |              [ 4,  5]],
 |             [[ 6,  7],
 |              [ 8,  9],
 |              [10, 11]],
 |             [[12, 13],
 |              [14, 15],
 |              [16, 17]],
 |             [[18, 19],
 |              [20, 21],
 |              [22, 23]]])
 |      Coordinates:
 |        * items       (items) object 'A' 'B' 'C' 'D'
 |        * major_axis  (major_axis) datetime64[ns] 2013-01-01 2013-01-02 2013-01-03  # noqa
 |        * minor_axis  (minor_axis) object 'first' 'second'
 |      
 |      Notes
 |      -----
 |      See the `xarray docs <http://xarray.pydata.org/en/stable/>`__
 |  
 |  truncate(self, before=None, after=None, axis=None, copy=True)
 |      Truncates a sorted NDFrame before and/or after some particular
 |      index value. If the axis contains only datetime values, before/after
 |      parameters are converted to datetime values.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before index value
 |      after : date
 |          Truncate after index value
 |      axis : the truncation axis, defaults to the stat axis
 |      copy : boolean, default is True,
 |          return a copy of the truncated section
 |      
 |      Returns
 |      -------
 |      truncated : type of caller
 |  
 |  tshift(self, periods=1, freq=None, axis=0)
 |      Shift the time index, using the index's frequency if available.
 |      
 |      Parameters
 |      ----------
 |      periods : int
 |          Number of periods to move, can be positive or negative
 |      freq : DateOffset, timedelta, or time rule string, default None
 |          Increment to use from the tseries module or time rule (e.g. 'EOM')
 |      axis : int or basestring
 |          Corresponds to the axis that contains the Index
 |      
 |      Notes
 |      -----
 |      If freq is not specified then tries to use the freq or inferred_freq
 |      attributes of the index. If neither of those attributes exist, a
 |      ValueError is thrown
 |      
 |      Returns
 |      -------
 |      shifted : NDFrame
 |  
 |  tz_convert(self, tz, axis=0, level=None, copy=True)
 |      Convert tz-aware axis to target time zone.
 |      
 |      Parameters
 |      ----------
 |      tz : string or pytz.timezone object
 |      axis : the axis to convert
 |      level : int, str, default None
 |          If axis ia a MultiIndex, convert a specific level. Otherwise
 |          must be None
 |      copy : boolean, default True
 |          Also make a copy of the underlying data
 |      
 |      Returns
 |      -------
 |      
 |      Raises
 |      ------
 |      TypeError
 |          If the axis is tz-naive.
 |  
 |  tz_localize(self, tz, axis=0, level=None, copy=True, ambiguous='raise')
 |      Localize tz-naive TimeSeries to target time zone.
 |      
 |      Parameters
 |      ----------
 |      tz : string or pytz.timezone object
 |      axis : the axis to localize
 |      level : int, str, default None
 |          If axis ia a MultiIndex, localize a specific level. Otherwise
 |          must be None
 |      copy : boolean, default True
 |          Also make a copy of the underlying data
 |      ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
 |          - 'infer' will attempt to infer fall dst-transition hours based on
 |            order
 |          - bool-ndarray where True signifies a DST time, False designates
 |            a non-DST time (note that this flag is only applicable for
 |            ambiguous times)
 |          - 'NaT' will return NaT where there are ambiguous times
 |          - 'raise' will raise an AmbiguousTimeError if there are ambiguous
 |            times
 |      infer_dst : boolean, default False (DEPRECATED)
 |          Attempt to infer fall dst-transition hours based on order
 |      
 |      Returns
 |      -------
 |      
 |      Raises
 |      ------
 |      TypeError
 |          If the TimeSeries is tz-aware and tz is not None.
 |  
 |  where(self, cond, other=nan, inplace=False, axis=None, level=None, try_cast=False, raise_on_error=True)
 |      Return an object of same shape as self and whose corresponding
 |      entries are from self where cond is True and otherwise are from
 |      other.
 |      
 |      Parameters
 |      ----------
 |      cond : boolean NDFrame, array-like, or callable
 |          If cond is callable, it is computed on the NDFrame and
 |          should return boolean NDFrame or array. The callable must
 |          not change input NDFrame (though pandas doesn't check it).
 |      
 |          .. versionadded:: 0.18.1
 |              A callable can be used as cond.
 |      
 |      other : scalar, NDFrame, or callable
 |          If other is callable, it is computed on the NDFrame and
 |          should return scalar or NDFrame. The callable must not
 |          change input NDFrame (though pandas doesn't check it).
 |      
 |          .. versionadded:: 0.18.1
 |              A callable can be used as other.
 |      
 |      inplace : boolean, default False
 |          Whether to perform the operation in place on the data
 |      axis : alignment axis if needed, default None
 |      level : alignment level if needed, default None
 |      try_cast : boolean, default False
 |          try to cast the result back to the input type (if possible),
 |      raise_on_error : boolean, default True
 |          Whether to raise on invalid data types (e.g. trying to where on
 |          strings)
 |      
 |      Returns
 |      -------
 |      wh : same type as caller
 |      
 |      Notes
 |      -----
 |      The where method is an application of the if-then idiom. For each
 |      element in the calling DataFrame, if ``cond`` is ``True`` the
 |      element is used; otherwise the corresponding element from the DataFrame
 |      ``other`` is used.
 |      
 |      The signature for :func:`DataFrame.where` differs from
 |      :func:`numpy.where`. Roughly ``df1.where(m, df2)`` is equivalent to
 |      ``np.where(m, df1, df2)``.
 |      
 |      For further details and examples see the ``where`` documentation in
 |      :ref:`indexing <indexing.where_mask>`.
 |      
 |      Examples
 |      --------
 |      >>> s = pd.Series(range(5))
 |      >>> s.where(s > 0)
 |      0    NaN
 |      1    1.0
 |      2    2.0
 |      3    3.0
 |      4    4.0
 |      
 |      >>> df = pd.DataFrame(np.arange(10).reshape(-1, 2), columns=['A', 'B'])
 |      >>> m = df % 3 == 0
 |      >>> df.where(m, -df)
 |         A  B
 |      0  0 -1
 |      1 -2  3
 |      2 -4 -5
 |      3  6 -7
 |      4 -8  9
 |      >>> df.where(m, -df) == np.where(m, df, -df)
 |            A     B
 |      0  True  True
 |      1  True  True
 |      2  True  True
 |      3  True  True
 |      4  True  True
 |      >>> df.where(m, -df) == df.mask(~m, -df)
 |            A     B
 |      0  True  True
 |      1  True  True
 |      2  True  True
 |      3  True  True
 |      4  True  True
 |      
 |      See Also
 |      --------
 |      :func:`DataFrame.mask`
 |  
 |  xs(self, key, axis=0, level=None, drop_level=True)
 |      Returns a cross-section (row(s) or column(s)) from the
 |      Series/DataFrame. Defaults to cross-section on the rows (axis=0).
 |      
 |      Parameters
 |      ----------
 |      key : object
 |          Some label contained in the index, or partially in a MultiIndex
 |      axis : int, default 0
 |          Axis to retrieve cross-section on
 |      level : object, defaults to first n levels (n=1 or len(key))
 |          In case of a key partially contained in a MultiIndex, indicate
 |          which levels are used. Levels can be referred by label or position.
 |      drop_level : boolean, default True
 |          If False, returns object with same levels as self.
 |      
 |      Examples
 |      --------
 |      >>> df
 |         A  B  C
 |      a  4  5  2
 |      b  4  0  9
 |      c  9  7  3
 |      >>> df.xs('a')
 |      A    4
 |      B    5
 |      C    2
 |      Name: a
 |      >>> df.xs('C', axis=1)
 |      a    2
 |      b    9
 |      c    3
 |      Name: C
 |      
 |      >>> df
 |                          A  B  C  D
 |      first second third
 |      bar   one    1      4  1  8  9
 |            two    1      7  5  5  0
 |      baz   one    1      6  6  8  0
 |            three  2      5  3  5  3
 |      >>> df.xs(('baz', 'three'))
 |             A  B  C  D
 |      third
 |      2      5  3  5  3
 |      >>> df.xs('one', level=1)
 |                   A  B  C  D
 |      first third
 |      bar   1      4  1  8  9
 |      baz   1      6  6  8  0
 |      >>> df.xs(('baz', 2), level=[0, 'third'])
 |              A  B  C  D
 |      second
 |      three   5  3  5  3
 |      
 |      Returns
 |      -------
 |      xs : Series or DataFrame
 |      
 |      Notes
 |      -----
 |      xs is only for getting, not setting values.
 |      
 |      MultiIndex Slicers is a generic way to get/set values on any level or
 |      levels.  It is a superset of xs functionality, see
 |      :ref:`MultiIndex Slicers <advanced.mi_slicers>`
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pandas.core.generic.NDFrame:
 |  
 |  at
 |      Fast label-based scalar accessor
 |      
 |      Similarly to ``loc``, ``at`` provides **label** based scalar lookups.
 |      You can also set using these indexers.
 |  
 |  blocks
 |      Internal property, property synonym for as_blocks()
 |  
 |  iat
 |      Fast integer location scalar accessor.
 |      
 |      Similarly to ``iloc``, ``iat`` provides **integer** based lookups.
 |      You can also set using these indexers.
 |  
 |  iloc
 |      Purely integer-location based indexing for selection by position.
 |      
 |      ``.iloc[]`` is primarily integer position based (from ``0`` to
 |      ``length-1`` of the axis), but may also be used with a boolean
 |      array.
 |      
 |      Allowed inputs are:
 |      
 |      - An integer, e.g. ``5``.
 |      - A list or array of integers, e.g. ``[4, 3, 0]``.
 |      - A slice object with ints, e.g. ``1:7``.
 |      - A boolean array.
 |      - A ``callable`` function with one argument (the calling Series, DataFrame
 |        or Panel) and that returns valid output for indexing (one of the above)
 |      
 |      ``.iloc`` will raise ``IndexError`` if a requested indexer is
 |      out-of-bounds, except *slice* indexers which allow out-of-bounds
 |      indexing (this conforms with python/numpy *slice* semantics).
 |      
 |      See more at :ref:`Selection by Position <indexing.integer>`
 |  
 |  ix
 |      A primarily label-location based indexer, with integer position
 |      fallback.
 |      
 |      ``.ix[]`` supports mixed integer and label based access. It is
 |      primarily label based, but will fall back to integer positional
 |      access unless the corresponding axis is of integer type.
 |      
 |      ``.ix`` is the most general indexer and will support any of the
 |      inputs in ``.loc`` and ``.iloc``. ``.ix`` also supports floating
 |      point label schemes. ``.ix`` is exceptionally useful when dealing
 |      with mixed positional and label based hierachical indexes.
 |      
 |      However, when an axis is integer based, ONLY label based access
 |      and not positional access is supported. Thus, in such cases, it's
 |      usually better to be explicit and use ``.iloc`` or ``.loc``.
 |      
 |      See more at :ref:`Advanced Indexing <advanced>`.
 |  
 |  loc
 |      Purely label-location based indexer for selection by label.
 |      
 |      ``.loc[]`` is primarily label based, but may also be used with a
 |      boolean array.
 |      
 |      Allowed inputs are:
 |      
 |      - A single label, e.g. ``5`` or ``'a'``, (note that ``5`` is
 |        interpreted as a *label* of the index, and **never** as an
 |        integer position along the index).
 |      - A list or array of labels, e.g. ``['a', 'b', 'c']``.
 |      - A slice object with labels, e.g. ``'a':'f'`` (note that contrary
 |        to usual python slices, **both** the start and the stop are included!).
 |      - A boolean array.
 |      - A ``callable`` function with one argument (the calling Series, DataFrame
 |        or Panel) and that returns valid output for indexing (one of the above)
 |      
 |      ``.loc`` will raise a ``KeyError`` when the items are not found.
 |      
 |      See more at :ref:`Selection by Label <indexing.label>`
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes inherited from pandas.core.generic.NDFrame:
 |  
 |  is_copy = None
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.base.PandasObject:
 |  
 |  __dir__(self)
 |      Provide method name lookup and completion
 |      Only provide 'public' methods
 |  
 |  __sizeof__(self)
 |      Generates the total memory usage for a object that returns
 |      either a value or Series of values
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.base.StringMixin:
 |  
 |  __bytes__(self)
 |      Return a string representation for a particular object.
 |      
 |      Invoked by bytes(obj) in py3 only.
 |      Yields a bytestring in both py2/py3.
 |  
 |  __repr__(self)
 |      Return a string representation for a particular object.
 |      
 |      Yields Bytestring in Py2, Unicode String in py3.
 |  
 |  __str__(self)
 |      Return a string representation for a particular Object
 |      
 |      Invoked by str(df) in both py2/py3.
 |      Yields Bytestring in Py2, Unicode String in py3.

m.

A    Jan
B    Feb
C    Mar
D    Apr
E    Jan
F    Feb
G    Mar
H    Apr
I    Jan
J    Feb
K    Mar
L    Apr
M    Jan
N    Feb
O    Mar
P    Apr
Q    Jan
R    Feb
S    Mar
T    Apr
Name: months, dtype: object

import datetime

d1 = datetime.datetime(2000, 1, 1)
d2 = datetime.datetime(2000, 1, 2)

d1 == d2

False

if d2 > d1 :
    print("Later")

Later

pd.date_range("2001-01-01", periods=20, freq="T")

DatetimeIndex(['2001-01-01 00:00:00', '2001-01-01 00:01:00',
               '2001-01-01 00:02:00', '2001-01-01 00:03:00',
               '2001-01-01 00:04:00', '2001-01-01 00:05:00',
               '2001-01-01 00:06:00', '2001-01-01 00:07:00',
               '2001-01-01 00:08:00', '2001-01-01 00:09:00',
               '2001-01-01 00:10:00', '2001-01-01 00:11:00',
               '2001-01-01 00:12:00', '2001-01-01 00:13:00',
               '2001-01-01 00:14:00', '2001-01-01 00:15:00',
               '2001-01-01 00:16:00', '2001-01-01 00:17:00',
               '2001-01-01 00:18:00', '2001-01-01 00:19:00'],
              dtype='datetime64[ns]', freq='T')

help(pd.date_range)

Help on function date_range in module pandas.core.indexes.datetimes:

date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs)
    Return a fixed frequency datetime index, with day (calendar) as the default
    frequency
    
    Parameters
    ----------
    start : string or datetime-like, default None
        Left bound for generating dates
    end : string or datetime-like, default None
        Right bound for generating dates
    periods : integer or None, default None
        If None, must specify start and end
    freq : string or DateOffset, default 'D' (calendar daily)
        Frequency strings can have multiples, e.g. '5H'
    tz : string or None
        Time zone name for returning localized DatetimeIndex, for example
        Asia/Hong_Kong
    normalize : bool, default False
        Normalize start/end dates to midnight before generating date range
    name : str, default None
        Name of the resulting index
    closed : string or None, default None
        Make the interval closed with respect to the given frequency to
        the 'left', 'right', or both sides (None)
    
    Notes
    -----
    2 of start, end, or periods must be specified
    
    To learn more about the frequency strings, please see `this link
    <http://pandas.pydata.org/pandas-docs/stable/timeseries.html#offset-aliases>`__.
    
    Returns
    -------
    rng : DatetimeIndex

daterange = pd.date_range("2001-01-01", periods=20, freq="T")

df['time'] = daterange

dft = df.set_index("time")

dft

dft.resample("5T").mean()

hd = pd.read_csv("/home/vikrant/trainings/2018/arcesium-advanced-oct/HYDERABAD-weather.csv")

hd.head()

hd.groupby("month").mean().plot()

<matplotlib.axes._subplots.AxesSubplot at 0x7fbeec04f240>

%matplotlib inline

groupbymon = hd.groupby("month").mean()

del groupbymon['year']

groupbymon.plot()

<matplotlib.axes._subplots.AxesSubplot at 0x7fbeec0069b0>

groupbymon.plot("maxtemp", "rainfall", kind="scatter")

<matplotlib.axes._subplots.AxesSubplot at 0x7fbee3d11b38>

Basics of GUI¶

import tkinter

from tkinter import Tk

root = Tk()
root.mainloop()
root.destroy

help(root)

Help on Tk in module tkinter object:

class Tk(Misc, Wm)
 |  Toplevel widget of Tk which represents mostly the main window
 |  of an application. It has an associated Tcl interpreter.
 |  
 |  Method resolution order:
 |      Tk
 |      Misc
 |      Wm
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __getattr__(self, attr)
 |      Delegate attribute access to the interpreter object
 |  
 |  __init__(self, screenName=None, baseName=None, className='Tk', useTk=1, sync=0, use=None)
 |      Return a new Toplevel widget on screen SCREENNAME. A new Tcl interpreter will
 |      be created. BASENAME will be used for the identification of the profile file (see
 |      readprofile).
 |      It is constructed from sys.argv[0] without extensions if None is given. CLASSNAME
 |      is the name of the widget class.
 |  
 |  destroy(self)
 |      Destroy this and all descendants widgets. This will
 |      end the application of this Tcl interpreter.
 |  
 |  loadtk(self)
 |  
 |  readprofile(self, baseName, className)
 |      Internal function. It reads BASENAME.tcl and CLASSNAME.tcl into
 |      the Tcl Interpreter and calls exec on the contents of BASENAME.py and
 |      CLASSNAME.py if such a file exists in the home directory.
 |  
 |  report_callback_exception(self, exc, val, tb)
 |      Report callback exception on sys.stderr.
 |      
 |      Applications may want to override this internal function, and
 |      should when sys.stderr is None.
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from Misc:
 |  
 |  __getitem__ = cget(self, key)
 |      Return the resource value for a KEY given as string.
 |  
 |  __repr__(self)
 |      Return repr(self).
 |  
 |  __setitem__(self, key, value)
 |  
 |  __str__(self)
 |      Return the window path name of this widget.
 |  
 |  after(self, ms, func=None, *args)
 |      Call function once after given time.
 |      
 |      MS specifies the time in milliseconds. FUNC gives the
 |      function which shall be called. Additional parameters
 |      are given as parameters to the function call.  Return
 |      identifier to cancel scheduling with after_cancel.
 |  
 |  after_cancel(self, id)
 |      Cancel scheduling of function identified with ID.
 |      
 |      Identifier returned by after or after_idle must be
 |      given as first parameter.
 |  
 |  after_idle(self, func, *args)
 |      Call FUNC once if the Tcl main loop has no event to
 |      process.
 |      
 |      Return an identifier to cancel the scheduling with
 |      after_cancel.
 |  
 |  anchor = grid_anchor(self, anchor=None)
 |      The anchor value controls how to place the grid within the
 |      master when no row/column has any weight.
 |      
 |      The default anchor is nw.
 |  
 |  bbox = grid_bbox(self, column=None, row=None, col2=None, row2=None)
 |      Return a tuple of integer coordinates for the bounding
 |      box of this widget controlled by the geometry manager grid.
 |      
 |      If COLUMN, ROW is given the bounding box applies from
 |      the cell with row and column 0 to the specified
 |      cell. If COL2 and ROW2 are given the bounding box
 |      starts at that cell.
 |      
 |      The returned integers specify the offset of the upper left
 |      corner in the master widget and the width and height.
 |  
 |  bell(self, displayof=0)
 |      Ring a display's bell.
 |  
 |  bind(self, sequence=None, func=None, add=None)
 |      Bind to this widget at event SEQUENCE a call to function FUNC.
 |      
 |      SEQUENCE is a string of concatenated event
 |      patterns. An event pattern is of the form
 |      <MODIFIER-MODIFIER-TYPE-DETAIL> where MODIFIER is one
 |      of Control, Mod2, M2, Shift, Mod3, M3, Lock, Mod4, M4,
 |      Button1, B1, Mod5, M5 Button2, B2, Meta, M, Button3,
 |      B3, Alt, Button4, B4, Double, Button5, B5 Triple,
 |      Mod1, M1. TYPE is one of Activate, Enter, Map,
 |      ButtonPress, Button, Expose, Motion, ButtonRelease
 |      FocusIn, MouseWheel, Circulate, FocusOut, Property,
 |      Colormap, Gravity Reparent, Configure, KeyPress, Key,
 |      Unmap, Deactivate, KeyRelease Visibility, Destroy,
 |      Leave and DETAIL is the button number for ButtonPress,
 |      ButtonRelease and DETAIL is the Keysym for KeyPress and
 |      KeyRelease. Examples are
 |      <Control-Button-1> for pressing Control and mouse button 1 or
 |      <Alt-A> for pressing A and the Alt key (KeyPress can be omitted).
 |      An event pattern can also be a virtual event of the form
 |      <<AString>> where AString can be arbitrary. This
 |      event can be generated by event_generate.
 |      If events are concatenated they must appear shortly
 |      after each other.
 |      
 |      FUNC will be called if the event sequence occurs with an
 |      instance of Event as argument. If the return value of FUNC is
 |      "break" no further bound function is invoked.
 |      
 |      An additional boolean parameter ADD specifies whether FUNC will
 |      be called additionally to the other bound function or whether
 |      it will replace the previous function.
 |      
 |      Bind will return an identifier to allow deletion of the bound function with
 |      unbind without memory leak.
 |      
 |      If FUNC or SEQUENCE is omitted the bound function or list
 |      of bound events are returned.
 |  
 |  bind_all(self, sequence=None, func=None, add=None)
 |      Bind to all widgets at an event SEQUENCE a call to function FUNC.
 |      An additional boolean parameter ADD specifies whether FUNC will
 |      be called additionally to the other bound function or whether
 |      it will replace the previous function. See bind for the return value.
 |  
 |  bind_class(self, className, sequence=None, func=None, add=None)
 |      Bind to widgets with bindtag CLASSNAME at event
 |      SEQUENCE a call of function FUNC. An additional
 |      boolean parameter ADD specifies whether FUNC will be
 |      called additionally to the other bound function or
 |      whether it will replace the previous function. See bind for
 |      the return value.
 |  
 |  bindtags(self, tagList=None)
 |      Set or get the list of bindtags for this widget.
 |      
 |      With no argument return the list of all bindtags associated with
 |      this widget. With a list of strings as argument the bindtags are
 |      set to this list. The bindtags determine in which order events are
 |      processed (see bind).
 |  
 |  cget(self, key)
 |      Return the resource value for a KEY given as string.
 |  
 |  clipboard_append(self, string, **kw)
 |      Append STRING to the Tk clipboard.
 |      
 |      A widget specified at the optional displayof keyword
 |      argument specifies the target display. The clipboard
 |      can be retrieved with selection_get.
 |  
 |  clipboard_clear(self, **kw)
 |      Clear the data in the Tk clipboard.
 |      
 |      A widget specified for the optional displayof keyword
 |      argument specifies the target display.
 |  
 |  clipboard_get(self, **kw)
 |      Retrieve data from the clipboard on window's display.
 |      
 |      The window keyword defaults to the root window of the Tkinter
 |      application.
 |      
 |      The type keyword specifies the form in which the data is
 |      to be returned and should be an atom name such as STRING
 |      or FILE_NAME.  Type defaults to STRING, except on X11, where the default
 |      is to try UTF8_STRING and fall back to STRING.
 |      
 |      This command is equivalent to:
 |      
 |      selection_get(CLIPBOARD)
 |  
 |  columnconfigure = grid_columnconfigure(self, index, cnf={}, **kw)
 |      Configure column INDEX of a grid.
 |      
 |      Valid resources are minsize (minimum size of the column),
 |      weight (how much does additional space propagate to this column)
 |      and pad (how much space to let additionally).
 |  
 |  config = configure(self, cnf=None, **kw)
 |      Configure resources of a widget.
 |      
 |      The values for resources are specified as keyword
 |      arguments. To get an overview about
 |      the allowed keyword arguments call the method keys.
 |  
 |  configure(self, cnf=None, **kw)
 |      Configure resources of a widget.
 |      
 |      The values for resources are specified as keyword
 |      arguments. To get an overview about
 |      the allowed keyword arguments call the method keys.
 |  
 |  deletecommand(self, name)
 |      Internal function.
 |      
 |      Delete the Tcl command provided in NAME.
 |  
 |  event_add(self, virtual, *sequences)
 |      Bind a virtual event VIRTUAL (of the form <<Name>>)
 |      to an event SEQUENCE such that the virtual event is triggered
 |      whenever SEQUENCE occurs.
 |  
 |  event_delete(self, virtual, *sequences)
 |      Unbind a virtual event VIRTUAL from SEQUENCE.
 |  
 |  event_generate(self, sequence, **kw)
 |      Generate an event SEQUENCE. Additional
 |      keyword arguments specify parameter of the event
 |      (e.g. x, y, rootx, rooty).
 |  
 |  event_info(self, virtual=None)
 |      Return a list of all virtual events or the information
 |      about the SEQUENCE bound to the virtual event VIRTUAL.
 |  
 |  focus = focus_set(self)
 |      Direct input focus to this widget.
 |      
 |      If the application currently does not have the focus
 |      this widget will get the focus if the application gets
 |      the focus through the window manager.
 |  
 |  focus_displayof(self)
 |      Return the widget which has currently the focus on the
 |      display where this widget is located.
 |      
 |      Return None if the application does not have the focus.
 |  
 |  focus_force(self)
 |      Direct input focus to this widget even if the
 |      application does not have the focus. Use with
 |      caution!
 |  
 |  focus_get(self)
 |      Return the widget which has currently the focus in the
 |      application.
 |      
 |      Use focus_displayof to allow working with several
 |      displays. Return None if application does not have
 |      the focus.
 |  
 |  focus_lastfor(self)
 |      Return the widget which would have the focus if top level
 |      for this widget gets the focus from the window manager.
 |  
 |  focus_set(self)
 |      Direct input focus to this widget.
 |      
 |      If the application currently does not have the focus
 |      this widget will get the focus if the application gets
 |      the focus through the window manager.
 |  
 |  getboolean(self, s)
 |      Return a boolean value for Tcl boolean values true and false given as parameter.
 |  
 |  getdouble(self, s)
 |  
 |  getint(self, s)
 |  
 |  getvar(self, name='PY_VAR')
 |      Return value of Tcl variable NAME.
 |  
 |  grab_current(self)
 |      Return widget which has currently the grab in this application
 |      or None.
 |  
 |  grab_release(self)
 |      Release grab for this widget if currently set.
 |  
 |  grab_set(self)
 |      Set grab for this widget.
 |      
 |      A grab directs all events to this and descendant
 |      widgets in the application.
 |  
 |  grab_set_global(self)
 |      Set global grab for this widget.
 |      
 |      A global grab directs all events to this and
 |      descendant widgets on the display. Use with caution -
 |      other applications do not get events anymore.
 |  
 |  grab_status(self)
 |      Return None, "local" or "global" if this widget has
 |      no, a local or a global grab.
 |  
 |  grid_anchor(self, anchor=None)
 |      The anchor value controls how to place the grid within the
 |      master when no row/column has any weight.
 |      
 |      The default anchor is nw.
 |  
 |  grid_bbox(self, column=None, row=None, col2=None, row2=None)
 |      Return a tuple of integer coordinates for the bounding
 |      box of this widget controlled by the geometry manager grid.
 |      
 |      If COLUMN, ROW is given the bounding box applies from
 |      the cell with row and column 0 to the specified
 |      cell. If COL2 and ROW2 are given the bounding box
 |      starts at that cell.
 |      
 |      The returned integers specify the offset of the upper left
 |      corner in the master widget and the width and height.
 |  
 |  grid_columnconfigure(self, index, cnf={}, **kw)
 |      Configure column INDEX of a grid.
 |      
 |      Valid resources are minsize (minimum size of the column),
 |      weight (how much does additional space propagate to this column)
 |      and pad (how much space to let additionally).
 |  
 |  grid_location(self, x, y)
 |      Return a tuple of column and row which identify the cell
 |      at which the pixel at position X and Y inside the master
 |      widget is located.
 |  
 |  grid_propagate(self, flag=['_noarg_'])
 |      Set or get the status for propagation of geometry information.
 |      
 |      A boolean argument specifies whether the geometry information
 |      of the slaves will determine the size of this widget. If no argument
 |      is given, the current setting will be returned.
 |  
 |  grid_rowconfigure(self, index, cnf={}, **kw)
 |      Configure row INDEX of a grid.
 |      
 |      Valid resources are minsize (minimum size of the row),
 |      weight (how much does additional space propagate to this row)
 |      and pad (how much space to let additionally).
 |  
 |  grid_size(self)
 |      Return a tuple of the number of column and rows in the grid.
 |  
 |  grid_slaves(self, row=None, column=None)
 |      Return a list of all slaves of this widget
 |      in its packing order.
 |  
 |  image_names(self)
 |      Return a list of all existing image names.
 |  
 |  image_types(self)
 |      Return a list of all available image types (e.g. photo bitmap).
 |  
 |  keys(self)
 |      Return a list of all resource names of this widget.
 |  
 |  lift = tkraise(self, aboveThis=None)
 |      Raise this widget in the stacking order.
 |  
 |  lower(self, belowThis=None)
 |      Lower this widget in the stacking order.
 |  
 |  mainloop(self, n=0)
 |      Call the mainloop of Tk.
 |  
 |  nametowidget(self, name)
 |      Return the Tkinter instance of a widget identified by
 |      its Tcl name NAME.
 |  
 |  option_add(self, pattern, value, priority=None)
 |      Set a VALUE (second parameter) for an option
 |      PATTERN (first parameter).
 |      
 |      An optional third parameter gives the numeric priority
 |      (defaults to 80).
 |  
 |  option_clear(self)
 |      Clear the option database.
 |      
 |      It will be reloaded if option_add is called.
 |  
 |  option_get(self, name, className)
 |      Return the value for an option NAME for this widget
 |      with CLASSNAME.
 |      
 |      Values with higher priority override lower values.
 |  
 |  option_readfile(self, fileName, priority=None)
 |      Read file FILENAME into the option database.
 |      
 |      An optional second parameter gives the numeric
 |      priority.
 |  
 |  pack_propagate(self, flag=['_noarg_'])
 |      Set or get the status for propagation of geometry information.
 |      
 |      A boolean argument specifies whether the geometry information
 |      of the slaves will determine the size of this widget. If no argument
 |      is given the current setting will be returned.
 |  
 |  pack_slaves(self)
 |      Return a list of all slaves of this widget
 |      in its packing order.
 |  
 |  place_slaves(self)
 |      Return a list of all slaves of this widget
 |      in its packing order.
 |  
 |  propagate = pack_propagate(self, flag=['_noarg_'])
 |      Set or get the status for propagation of geometry information.
 |      
 |      A boolean argument specifies whether the geometry information
 |      of the slaves will determine the size of this widget. If no argument
 |      is given the current setting will be returned.
 |  
 |  quit(self)
 |      Quit the Tcl interpreter. All widgets will be destroyed.
 |  
 |  register = _register(self, func, subst=None, needcleanup=1)
 |      Return a newly created Tcl function. If this
 |      function is called, the Python function FUNC will
 |      be executed. An optional function SUBST can
 |      be given which will be executed before FUNC.
 |  
 |  rowconfigure = grid_rowconfigure(self, index, cnf={}, **kw)
 |      Configure row INDEX of a grid.
 |      
 |      Valid resources are minsize (minimum size of the row),
 |      weight (how much does additional space propagate to this row)
 |      and pad (how much space to let additionally).
 |  
 |  selection_clear(self, **kw)
 |      Clear the current X selection.
 |  
 |  selection_get(self, **kw)
 |      Return the contents of the current X selection.
 |      
 |      A keyword parameter selection specifies the name of
 |      the selection and defaults to PRIMARY.  A keyword
 |      parameter displayof specifies a widget on the display
 |      to use. A keyword parameter type specifies the form of data to be
 |      fetched, defaulting to STRING except on X11, where UTF8_STRING is tried
 |      before STRING.
 |  
 |  selection_handle(self, command, **kw)
 |      Specify a function COMMAND to call if the X
 |      selection owned by this widget is queried by another
 |      application.
 |      
 |      This function must return the contents of the
 |      selection. The function will be called with the
 |      arguments OFFSET and LENGTH which allows the chunking
 |      of very long selections. The following keyword
 |      parameters can be provided:
 |      selection - name of the selection (default PRIMARY),
 |      type - type of the selection (e.g. STRING, FILE_NAME).
 |  
 |  selection_own(self, **kw)
 |      Become owner of X selection.
 |      
 |      A keyword parameter selection specifies the name of
 |      the selection (default PRIMARY).
 |  
 |  selection_own_get(self, **kw)
 |      Return owner of X selection.
 |      
 |      The following keyword parameter can
 |      be provided:
 |      selection - name of the selection (default PRIMARY),
 |      type - type of the selection (e.g. STRING, FILE_NAME).
 |  
 |  send(self, interp, cmd, *args)
 |      Send Tcl command CMD to different interpreter INTERP to be executed.
 |  
 |  setvar(self, name='PY_VAR', value='1')
 |      Set Tcl variable NAME to VALUE.
 |  
 |  size = grid_size(self)
 |      Return a tuple of the number of column and rows in the grid.
 |  
 |  slaves = pack_slaves(self)
 |      Return a list of all slaves of this widget
 |      in its packing order.
 |  
 |  tk_bisque(self)
 |      Change the color scheme to light brown as used in Tk 3.6 and before.
 |  
 |  tk_focusFollowsMouse(self)
 |      The widget under mouse will get automatically focus. Can not
 |      be disabled easily.
 |  
 |  tk_focusNext(self)
 |      Return the next widget in the focus order which follows
 |      widget which has currently the focus.
 |      
 |      The focus order first goes to the next child, then to
 |      the children of the child recursively and then to the
 |      next sibling which is higher in the stacking order.  A
 |      widget is omitted if it has the takefocus resource set
 |      to 0.
 |  
 |  tk_focusPrev(self)
 |      Return previous widget in the focus order. See tk_focusNext for details.
 |  
 |  tk_setPalette(self, *args, **kw)
 |      Set a new color scheme for all widget elements.
 |      
 |      A single color as argument will cause that all colors of Tk
 |      widget elements are derived from this.
 |      Alternatively several keyword parameters and its associated
 |      colors can be given. The following keywords are valid:
 |      activeBackground, foreground, selectColor,
 |      activeForeground, highlightBackground, selectBackground,
 |      background, highlightColor, selectForeground,
 |      disabledForeground, insertBackground, troughColor.
 |  
 |  tk_strictMotif(self, boolean=None)
 |      Set Tcl internal variable, whether the look and feel
 |      should adhere to Motif.
 |      
 |      A parameter of 1 means adhere to Motif (e.g. no color
 |      change if mouse passes over slider).
 |      Returns the set value.
 |  
 |  tkraise(self, aboveThis=None)
 |      Raise this widget in the stacking order.
 |  
 |  unbind(self, sequence, funcid=None)
 |      Unbind for this widget for event SEQUENCE  the
 |      function identified with FUNCID.
 |  
 |  unbind_all(self, sequence)
 |      Unbind for all widgets for event SEQUENCE all functions.
 |  
 |  unbind_class(self, className, sequence)
 |      Unbind for all widgets with bindtag CLASSNAME for event SEQUENCE
 |      all functions.
 |  
 |  update(self)
 |      Enter event loop until all pending events have been processed by Tcl.
 |  
 |  update_idletasks(self)
 |      Enter event loop until all idle callbacks have been called. This
 |      will update the display of windows but not process events caused by
 |      the user.
 |  
 |  wait_variable(self, name='PY_VAR')
 |      Wait until the variable is modified.
 |      
 |      A parameter of type IntVar, StringVar, DoubleVar or
 |      BooleanVar must be given.
 |  
 |  wait_visibility(self, window=None)
 |      Wait until the visibility of a WIDGET changes
 |      (e.g. it appears).
 |      
 |      If no parameter is given self is used.
 |  
 |  wait_window(self, window=None)
 |      Wait until a WIDGET is destroyed.
 |      
 |      If no parameter is given self is used.
 |  
 |  waitvar = wait_variable(self, name='PY_VAR')
 |      Wait until the variable is modified.
 |      
 |      A parameter of type IntVar, StringVar, DoubleVar or
 |      BooleanVar must be given.
 |  
 |  winfo_atom(self, name, displayof=0)
 |      Return integer which represents atom NAME.
 |  
 |  winfo_atomname(self, id, displayof=0)
 |      Return name of atom with identifier ID.
 |  
 |  winfo_cells(self)
 |      Return number of cells in the colormap for this widget.
 |  
 |  winfo_children(self)
 |      Return a list of all widgets which are children of this widget.
 |  
 |  winfo_class(self)
 |      Return window class name of this widget.
 |  
 |  winfo_colormapfull(self)
 |      Return true if at the last color request the colormap was full.
 |  
 |  winfo_containing(self, rootX, rootY, displayof=0)
 |      Return the widget which is at the root coordinates ROOTX, ROOTY.
 |  
 |  winfo_depth(self)
 |      Return the number of bits per pixel.
 |  
 |  winfo_exists(self)
 |      Return true if this widget exists.
 |  
 |  winfo_fpixels(self, number)
 |      Return the number of pixels for the given distance NUMBER
 |      (e.g. "3c") as float.
 |  
 |  winfo_geometry(self)
 |      Return geometry string for this widget in the form "widthxheight+X+Y".
 |  
 |  winfo_height(self)
 |      Return height of this widget.
 |  
 |  winfo_id(self)
 |      Return identifier ID for this widget.
 |  
 |  winfo_interps(self, displayof=0)
 |      Return the name of all Tcl interpreters for this display.
 |  
 |  winfo_ismapped(self)
 |      Return true if this widget is mapped.
 |  
 |  winfo_manager(self)
 |      Return the window manager name for this widget.
 |  
 |  winfo_name(self)
 |      Return the name of this widget.
 |  
 |  winfo_parent(self)
 |      Return the name of the parent of this widget.
 |  
 |  winfo_pathname(self, id, displayof=0)
 |      Return the pathname of the widget given by ID.
 |  
 |  winfo_pixels(self, number)
 |      Rounded integer value of winfo_fpixels.
 |  
 |  winfo_pointerx(self)
 |      Return the x coordinate of the pointer on the root window.
 |  
 |  winfo_pointerxy(self)
 |      Return a tuple of x and y coordinates of the pointer on the root window.
 |  
 |  winfo_pointery(self)
 |      Return the y coordinate of the pointer on the root window.
 |  
 |  winfo_reqheight(self)
 |      Return requested height of this widget.
 |  
 |  winfo_reqwidth(self)
 |      Return requested width of this widget.
 |  
 |  winfo_rgb(self, color)
 |      Return tuple of decimal values for red, green, blue for
 |      COLOR in this widget.
 |  
 |  winfo_rootx(self)
 |      Return x coordinate of upper left corner of this widget on the
 |      root window.
 |  
 |  winfo_rooty(self)
 |      Return y coordinate of upper left corner of this widget on the
 |      root window.
 |  
 |  winfo_screen(self)
 |      Return the screen name of this widget.
 |  
 |  winfo_screencells(self)
 |      Return the number of the cells in the colormap of the screen
 |      of this widget.
 |  
 |  winfo_screendepth(self)
 |      Return the number of bits per pixel of the root window of the
 |      screen of this widget.
 |  
 |  winfo_screenheight(self)
 |      Return the number of pixels of the height of the screen of this widget
 |      in pixel.
 |  
 |  winfo_screenmmheight(self)
 |      Return the number of pixels of the height of the screen of
 |      this widget in mm.
 |  
 |  winfo_screenmmwidth(self)
 |      Return the number of pixels of the width of the screen of
 |      this widget in mm.
 |  
 |  winfo_screenvisual(self)
 |      Return one of the strings directcolor, grayscale, pseudocolor,
 |      staticcolor, staticgray, or truecolor for the default
 |      colormodel of this screen.
 |  
 |  winfo_screenwidth(self)
 |      Return the number of pixels of the width of the screen of
 |      this widget in pixel.
 |  
 |  winfo_server(self)
 |      Return information of the X-Server of the screen of this widget in
 |      the form "XmajorRminor vendor vendorVersion".
 |  
 |  winfo_toplevel(self)
 |      Return the toplevel widget of this widget.
 |  
 |  winfo_viewable(self)
 |      Return true if the widget and all its higher ancestors are mapped.
 |  
 |  winfo_visual(self)
 |      Return one of the strings directcolor, grayscale, pseudocolor,
 |      staticcolor, staticgray, or truecolor for the
 |      colormodel of this widget.
 |  
 |  winfo_visualid(self)
 |      Return the X identifier for the visual for this widget.
 |  
 |  winfo_visualsavailable(self, includeids=False)
 |      Return a list of all visuals available for the screen
 |      of this widget.
 |      
 |      Each item in the list consists of a visual name (see winfo_visual), a
 |      depth and if includeids is true is given also the X identifier.
 |  
 |  winfo_vrootheight(self)
 |      Return the height of the virtual root window associated with this
 |      widget in pixels. If there is no virtual root window return the
 |      height of the screen.
 |  
 |  winfo_vrootwidth(self)
 |      Return the width of the virtual root window associated with this
 |      widget in pixel. If there is no virtual root window return the
 |      width of the screen.
 |  
 |  winfo_vrootx(self)
 |      Return the x offset of the virtual root relative to the root
 |      window of the screen of this widget.
 |  
 |  winfo_vrooty(self)
 |      Return the y offset of the virtual root relative to the root
 |      window of the screen of this widget.
 |  
 |  winfo_width(self)
 |      Return the width of this widget.
 |  
 |  winfo_x(self)
 |      Return the x coordinate of the upper left corner of this widget
 |      in the parent.
 |  
 |  winfo_y(self)
 |      Return the y coordinate of the upper left corner of this widget
 |      in the parent.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from Misc:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from Wm:
 |  
 |  aspect = wm_aspect(self, minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)
 |      Instruct the window manager to set the aspect ratio (width/height)
 |      of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
 |      of the actual values if no argument is given.
 |  
 |  attributes = wm_attributes(self, *args)
 |      This subcommand returns or sets platform specific attributes
 |      
 |      The first form returns a list of the platform specific flags and
 |      their values. The second form returns the value for the specific
 |      option. The third form sets one or more of the values. The values
 |      are as follows:
 |      
 |      On Windows, -disabled gets or sets whether the window is in a
 |      disabled state. -toolwindow gets or sets the style of the window
 |      to toolwindow (as defined in the MSDN). -topmost gets or sets
 |      whether this is a topmost window (displays above all other
 |      windows).
 |      
 |      On Macintosh, XXXXX
 |      
 |      On Unix, there are currently no special attribute values.
 |  
 |  client = wm_client(self, name=None)
 |      Store NAME in WM_CLIENT_MACHINE property of this widget. Return
 |      current value.
 |  
 |  colormapwindows = wm_colormapwindows(self, *wlist)
 |      Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
 |      of this widget. This list contains windows whose colormaps differ from their
 |      parents. Return current list of widgets if WLIST is empty.
 |  
 |  command = wm_command(self, value=None)
 |      Store VALUE in WM_COMMAND property. It is the command
 |      which shall be used to invoke the application. Return current
 |      command if VALUE is None.
 |  
 |  deiconify = wm_deiconify(self)
 |      Deiconify this widget. If it was never mapped it will not be mapped.
 |      On Windows it will raise this widget and give it the focus.
 |  
 |  focusmodel = wm_focusmodel(self, model=None)
 |      Set focus model to MODEL. "active" means that this widget will claim
 |      the focus itself, "passive" means that the window manager shall give
 |      the focus. Return current focus model if MODEL is None.
 |  
 |  forget = wm_forget(self, window)
 |      The window will be unmapped from the screen and will no longer
 |      be managed by wm. toplevel windows will be treated like frame
 |      windows once they are no longer managed by wm, however, the menu
 |      option configuration will be remembered and the menus will return
 |      once the widget is managed again.
 |  
 |  frame = wm_frame(self)
 |      Return identifier for decorative frame of this widget if present.
 |  
 |  geometry = wm_geometry(self, newGeometry=None)
 |      Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
 |      current value if None is given.
 |  
 |  grid = wm_grid(self, baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)
 |      Instruct the window manager that this widget shall only be
 |      resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
 |      height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
 |      number of grid units requested in Tk_GeometryRequest.
 |  
 |  group = wm_group(self, pathName=None)
 |      Set the group leader widgets for related widgets to PATHNAME. Return
 |      the group leader of this widget if None is given.
 |  
 |  iconbitmap = wm_iconbitmap(self, bitmap=None, default=None)
 |      Set bitmap for the iconified widget to BITMAP. Return
 |      the bitmap if None is given.
 |      
 |      Under Windows, the DEFAULT parameter can be used to set the icon
 |      for the widget and any descendents that don't have an icon set
 |      explicitly.  DEFAULT can be the relative path to a .ico file
 |      (example: root.iconbitmap(default='myicon.ico') ).  See Tk
 |      documentation for more information.
 |  
 |  iconify = wm_iconify(self)
 |      Display widget as icon.
 |  
 |  iconmask = wm_iconmask(self, bitmap=None)
 |      Set mask for the icon bitmap of this widget. Return the
 |      mask if None is given.
 |  
 |  iconname = wm_iconname(self, newName=None)
 |      Set the name of the icon for this widget. Return the name if
 |      None is given.
 |  
 |  iconphoto = wm_iconphoto(self, default=False, *args)
 |      Sets the titlebar icon for this window based on the named photo
 |      images passed through args. If default is True, this is applied to
 |      all future created toplevels as well.
 |      
 |      The data in the images is taken as a snapshot at the time of
 |      invocation. If the images are later changed, this is not reflected
 |      to the titlebar icons. Multiple images are accepted to allow
 |      different images sizes to be provided. The window manager may scale
 |      provided icons to an appropriate size.
 |      
 |      On Windows, the images are packed into a Windows icon structure.
 |      This will override an icon specified to wm_iconbitmap, and vice
 |      versa.
 |      
 |      On X, the images are arranged into the _NET_WM_ICON X property,
 |      which most modern window managers support. An icon specified by
 |      wm_iconbitmap may exist simultaneously.
 |      
 |      On Macintosh, this currently does nothing.
 |  
 |  iconposition = wm_iconposition(self, x=None, y=None)
 |      Set the position of the icon of this widget to X and Y. Return
 |      a tuple of the current values of X and X if None is given.
 |  
 |  iconwindow = wm_iconwindow(self, pathName=None)
 |      Set widget PATHNAME to be displayed instead of icon. Return the current
 |      value if None is given.
 |  
 |  manage = wm_manage(self, widget)
 |      The widget specified will become a stand alone top-level window.
 |      The window will be decorated with the window managers title bar,
 |      etc.
 |  
 |  maxsize = wm_maxsize(self, width=None, height=None)
 |      Set max WIDTH and HEIGHT for this widget. If the window is gridded
 |      the values are given in grid units. Return the current values if None
 |      is given.
 |  
 |  minsize = wm_minsize(self, width=None, height=None)
 |      Set min WIDTH and HEIGHT for this widget. If the window is gridded
 |      the values are given in grid units. Return the current values if None
 |      is given.
 |  
 |  overrideredirect = wm_overrideredirect(self, boolean=None)
 |      Instruct the window manager to ignore this widget
 |      if BOOLEAN is given with 1. Return the current value if None
 |      is given.
 |  
 |  positionfrom = wm_positionfrom(self, who=None)
 |      Instruct the window manager that the position of this widget shall
 |      be defined by the user if WHO is "user", and by its own policy if WHO is
 |      "program".
 |  
 |  protocol = wm_protocol(self, name=None, func=None)
 |      Bind function FUNC to command NAME for this widget.
 |      Return the function bound to NAME if None is given. NAME could be
 |      e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW".
 |  
 |  resizable = wm_resizable(self, width=None, height=None)
 |      Instruct the window manager whether this width can be resized
 |      in WIDTH or HEIGHT. Both values are boolean values.
 |  
 |  sizefrom = wm_sizefrom(self, who=None)
 |      Instruct the window manager that the size of this widget shall
 |      be defined by the user if WHO is "user", and by its own policy if WHO is
 |      "program".
 |  
 |  state = wm_state(self, newstate=None)
 |      Query or set the state of this widget as one of normal, icon,
 |      iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).
 |  
 |  title = wm_title(self, string=None)
 |      Set the title of this widget.
 |  
 |  transient = wm_transient(self, master=None)
 |      Instruct the window manager that this widget is transient
 |      with regard to widget MASTER.
 |  
 |  withdraw = wm_withdraw(self)
 |      Withdraw this widget from the screen such that it is unmapped
 |      and forgotten by the window manager. Re-draw it with wm_deiconify.
 |  
 |  wm_aspect(self, minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)
 |      Instruct the window manager to set the aspect ratio (width/height)
 |      of this widget to be between MINNUMER/MINDENOM and MAXNUMER/MAXDENOM. Return a tuple
 |      of the actual values if no argument is given.
 |  
 |  wm_attributes(self, *args)
 |      This subcommand returns or sets platform specific attributes
 |      
 |      The first form returns a list of the platform specific flags and
 |      their values. The second form returns the value for the specific
 |      option. The third form sets one or more of the values. The values
 |      are as follows:
 |      
 |      On Windows, -disabled gets or sets whether the window is in a
 |      disabled state. -toolwindow gets or sets the style of the window
 |      to toolwindow (as defined in the MSDN). -topmost gets or sets
 |      whether this is a topmost window (displays above all other
 |      windows).
 |      
 |      On Macintosh, XXXXX
 |      
 |      On Unix, there are currently no special attribute values.
 |  
 |  wm_client(self, name=None)
 |      Store NAME in WM_CLIENT_MACHINE property of this widget. Return
 |      current value.
 |  
 |  wm_colormapwindows(self, *wlist)
 |      Store list of window names (WLIST) into WM_COLORMAPWINDOWS property
 |      of this widget. This list contains windows whose colormaps differ from their
 |      parents. Return current list of widgets if WLIST is empty.
 |  
 |  wm_command(self, value=None)
 |      Store VALUE in WM_COMMAND property. It is the command
 |      which shall be used to invoke the application. Return current
 |      command if VALUE is None.
 |  
 |  wm_deiconify(self)
 |      Deiconify this widget. If it was never mapped it will not be mapped.
 |      On Windows it will raise this widget and give it the focus.
 |  
 |  wm_focusmodel(self, model=None)
 |      Set focus model to MODEL. "active" means that this widget will claim
 |      the focus itself, "passive" means that the window manager shall give
 |      the focus. Return current focus model if MODEL is None.
 |  
 |  wm_forget(self, window)
 |      The window will be unmapped from the screen and will no longer
 |      be managed by wm. toplevel windows will be treated like frame
 |      windows once they are no longer managed by wm, however, the menu
 |      option configuration will be remembered and the menus will return
 |      once the widget is managed again.
 |  
 |  wm_frame(self)
 |      Return identifier for decorative frame of this widget if present.
 |  
 |  wm_geometry(self, newGeometry=None)
 |      Set geometry to NEWGEOMETRY of the form =widthxheight+x+y. Return
 |      current value if None is given.
 |  
 |  wm_grid(self, baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)
 |      Instruct the window manager that this widget shall only be
 |      resized on grid boundaries. WIDTHINC and HEIGHTINC are the width and
 |      height of a grid unit in pixels. BASEWIDTH and BASEHEIGHT are the
 |      number of grid units requested in Tk_GeometryRequest.
 |  
 |  wm_group(self, pathName=None)
 |      Set the group leader widgets for related widgets to PATHNAME. Return
 |      the group leader of this widget if None is given.
 |  
 |  wm_iconbitmap(self, bitmap=None, default=None)
 |      Set bitmap for the iconified widget to BITMAP. Return
 |      the bitmap if None is given.
 |      
 |      Under Windows, the DEFAULT parameter can be used to set the icon
 |      for the widget and any descendents that don't have an icon set
 |      explicitly.  DEFAULT can be the relative path to a .ico file
 |      (example: root.iconbitmap(default='myicon.ico') ).  See Tk
 |      documentation for more information.
 |  
 |  wm_iconify(self)
 |      Display widget as icon.
 |  
 |  wm_iconmask(self, bitmap=None)
 |      Set mask for the icon bitmap of this widget. Return the
 |      mask if None is given.
 |  
 |  wm_iconname(self, newName=None)
 |      Set the name of the icon for this widget. Return the name if
 |      None is given.
 |  
 |  wm_iconphoto(self, default=False, *args)
 |      Sets the titlebar icon for this window based on the named photo
 |      images passed through args. If default is True, this is applied to
 |      all future created toplevels as well.
 |      
 |      The data in the images is taken as a snapshot at the time of
 |      invocation. If the images are later changed, this is not reflected
 |      to the titlebar icons. Multiple images are accepted to allow
 |      different images sizes to be provided. The window manager may scale
 |      provided icons to an appropriate size.
 |      
 |      On Windows, the images are packed into a Windows icon structure.
 |      This will override an icon specified to wm_iconbitmap, and vice
 |      versa.
 |      
 |      On X, the images are arranged into the _NET_WM_ICON X property,
 |      which most modern window managers support. An icon specified by
 |      wm_iconbitmap may exist simultaneously.
 |      
 |      On Macintosh, this currently does nothing.
 |  
 |  wm_iconposition(self, x=None, y=None)
 |      Set the position of the icon of this widget to X and Y. Return
 |      a tuple of the current values of X and X if None is given.
 |  
 |  wm_iconwindow(self, pathName=None)
 |      Set widget PATHNAME to be displayed instead of icon. Return the current
 |      value if None is given.
 |  
 |  wm_manage(self, widget)
 |      The widget specified will become a stand alone top-level window.
 |      The window will be decorated with the window managers title bar,
 |      etc.
 |  
 |  wm_maxsize(self, width=None, height=None)
 |      Set max WIDTH and HEIGHT for this widget. If the window is gridded
 |      the values are given in grid units. Return the current values if None
 |      is given.
 |  
 |  wm_minsize(self, width=None, height=None)
 |      Set min WIDTH and HEIGHT for this widget. If the window is gridded
 |      the values are given in grid units. Return the current values if None
 |      is given.
 |  
 |  wm_overrideredirect(self, boolean=None)
 |      Instruct the window manager to ignore this widget
 |      if BOOLEAN is given with 1. Return the current value if None
 |      is given.
 |  
 |  wm_positionfrom(self, who=None)
 |      Instruct the window manager that the position of this widget shall
 |      be defined by the user if WHO is "user", and by its own policy if WHO is
 |      "program".
 |  
 |  wm_protocol(self, name=None, func=None)
 |      Bind function FUNC to command NAME for this widget.
 |      Return the function bound to NAME if None is given. NAME could be
 |      e.g. "WM_SAVE_YOURSELF" or "WM_DELETE_WINDOW".
 |  
 |  wm_resizable(self, width=None, height=None)
 |      Instruct the window manager whether this width can be resized
 |      in WIDTH or HEIGHT. Both values are boolean values.
 |  
 |  wm_sizefrom(self, who=None)
 |      Instruct the window manager that the size of this widget shall
 |      be defined by the user if WHO is "user", and by its own policy if WHO is
 |      "program".
 |  
 |  wm_state(self, newstate=None)
 |      Query or set the state of this widget as one of normal, icon,
 |      iconic (see wm_iconwindow), withdrawn, or zoomed (Windows only).
 |  
 |  wm_title(self, string=None)
 |      Set the title of this widget.
 |  
 |  wm_transient(self, master=None)
 |      Instruct the window manager that this widget is transient
 |      with regard to widget MASTER.
 |  
 |  wm_withdraw(self)
 |      Withdraw this widget from the screen such that it is unmapped
 |      and forgotten by the window manager. Re-draw it with wm_deiconify.

def say_hello(master):
    button = tkinter.Button(master, text="hello", command=hello)
    button.pack()
    
    quit = tkinter.Button(master, text="quit", command=master.destroy)
    quit.pack()
    
def hello():
    print("Hello World!")


root = Tk()

say_hello(root)
root.mainloop()

Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!
Hello World!

def add(f, x, y):
    return f(x) + f(y)

import math

add(math.sin, 3.14, 3.14/2) #here sin is not called, it just passed as argument

%%file top.py

import tkinter
from tkinter import Frame, Button, Tk, Toplevel

class Top:

    def __init__(self, master):

        top = Toplevel(master, name="hello")
        top.title("Say hello!")

        self.button = Button(
            top, text="QUIT", fg="red", command=top.destroy
            )
        self.button.pack(side=tkinter.LEFT)

        self.hi_there = Button(top, text="Hello", command=self.say_hi)
        self.hi_there.pack(side=tkinter.LEFT)

    def say_hi(self):
        print("hi there, everyone!")


class App:

    def __init__(self, master):
        self.master = master
        frame = Frame(master)
        frame.pack()
        button = Button(frame, text="say hello", fg="yellow", command=self.create_top)
        button.pack()

    def create_top(self):
        Top(self.master)
        
root = Tk()

app = App(root)

root.mainloop()
root.destroy()

Overwriting top.py

!python top.py

hi there, everyone!
hi there, everyone!
hi there, everyone!
hi there, everyone!
Traceback (most recent call last):
  File "top.py", line 41, in <module>
    root.destroy()
  File "/home/vikrant/usr/local/anaconda3/lib/python3.6/tkinter/__init__.py", line 2056, in destroy
    self.tk.call('destroy', self._w)
_tkinter.TclError: can't invoke "destroy" command:  application has been destroyed

%%file menu.py

from tkinter import Tk, Menu, filedialog, Toplevel, Label, Button
import tkinter


class Top:

    def __init__(self, root, text):
        top = Toplevel(root)
        top.title("About")
        label = Label(top, text=text)
        label.pack(side=tkinter.TOP)
        quitabout = Button(top,text="Quit", command=top.destroy)
        quitabout.pack(side=tkinter.BOTTOM)
        

class App:


    def __init__(self, root):
        self.root = root
        menu = Menu(root)
        root.config(menu=menu)
        filemenu = Menu(menu)
        menu.add_cascade(label="File", menu=filemenu)
        filemenu.add_command(label="New", command=self.new)
        filemenu.add_command(label="Open", command=self.openfile)
        filemenu.add_separator()
        filemenu.add_command(label="Exit", command=self.closeapp)

        helpmenu = Menu(menu)
        menu.add_cascade(label="Help", menu=helpmenu)
        helpmenu.add_command(label="About", command=self.about)


    def new(self):
        print("new")

    def openfile(self):
        self.file = filedialog.askopenfilename()##there are multiple functions available for this

    def closeapp(self):
        self.root.destroy()

    def about(self):
        text = """
This App was developed as
part of training at Arvesium
        """
        Top(self.root, text)

root = Tk()
app = App(root)
root.mainloop()
root.destroy()

Overwriting menu.py

!python menu.py

new
Traceback (most recent call last):
  File "menu.py", line 55, in <module>
    root.destroy()
  File "/home/vikrant/usr/local/anaconda3/lib/python3.6/tkinter/__init__.py", line 2056, in destroy
    self.tk.call('destroy', self._w)
_tkinter.TclError: can't invoke "destroy" command:  application has been destroyed

from tkinter import Entry, StringVar

from tkinter import Entry
class App:

    def __init__(self, master):
        self.master = master
        frame = Frame(master)
        frame.pack()
        fv = StringVar()
        first = Entry(frame, label="First item")
        second = Entry(frame, label="Second item")
        first.grid(0)
        second.grid(1)

    def create_top(self):
        Top(self.master)
        
root = Tk()

app = App(root)

root.mainloop()
root.destroy()

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
A	101.936847	117.867972	123.117646	137.310277	145.225669	164.801372	164.505629	172.932600	187.521969	208.083851
B	107.330154	110.565738	124.560455	135.911015	150.145635	164.828529	166.261888	175.505530	182.919654	200.983054
C	100.056956	113.466984	126.656557	137.528260	148.221090	163.787465	173.165228	185.364674	193.339925	206.638803
D	101.982515	118.015626	121.079927	132.357782	140.447205	159.324663	174.087583	179.757828	193.103460	204.168656
E	105.387952	119.458270	123.718378	132.759167	147.050269	158.489241	175.590991	173.799474	182.277417	202.017999

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
A	102.881736	111.686637	125.768067	135.008350	146.256339	164.018163	160.873214	181.621327	181.374539	195.252783
B	104.643103	120.539003	131.558259	130.746813	151.919901	155.166632	162.056039	183.869076	187.649126	208.370151
C	108.179150	115.920925	130.148913	136.241632	142.379800	161.175068	169.736229	175.752240	195.241157	203.594022
D	106.809360	114.649024	120.845874	132.234681	145.526677	164.945085	160.749303	184.553126	182.148298	200.637020
E	103.622581	110.578896	126.619778	138.689920	151.376287	154.760999	169.530191	172.488564	193.210322	203.421211
F	104.936108	110.646026	130.562393	139.273275	150.599323	153.104681	161.397454	185.712803	189.787608	196.169446
G	106.384699	120.560680	120.133194	142.015991	150.649846	158.987409	162.148615	177.872405	195.190730	201.176754
H	100.903158	119.322304	124.330644	141.522500	151.311206	152.361455	175.752172	178.327134	191.671344	194.948743
I	102.998368	114.514920	125.796594	138.064040	152.328394	158.786569	164.540042	181.894790	192.609703	202.533701
J	106.381198	117.157913	127.583377	134.374511	147.187832	156.473112	170.101022	179.208536	184.741790	196.184813
K	105.763294	118.215099	126.443226	134.642078	143.745005	157.830239	175.135949	171.205422	190.182657	201.554441
L	104.145880	119.289749	130.368611	141.519833	152.557097	154.804981	170.686594	174.580763	196.137898	208.645578
M	107.849212	119.353107	120.380036	135.220999	143.895535	162.149316	173.411748	175.115706	196.903260	196.713319
N	101.402427	111.520606	128.514006	140.518595	143.770781	157.809266	168.588914	180.942099	185.290782	197.464044
O	102.190091	111.005516	123.230949	133.121732	140.521928	160.917509	173.708382	181.617705	197.630924	198.788927
P	103.973501	112.693003	125.325745	141.575813	149.185102	155.102063	168.249512	171.706624	193.119364	198.662881
Q	100.632228	111.774609	131.967359	133.780612	151.303292	164.480898	160.401945	179.886245	188.566514	199.597736
R	100.355248	120.428993	124.964826	133.592602	144.556759	164.274347	164.397666	177.254149	184.947193	197.488116
S	100.234149	120.691388	121.844195	131.378565	149.295697	163.977574	163.239052	179.250700	189.277920	204.305453
T	105.734044	117.356446	129.955418	136.344778	149.881037	160.662969	173.348414	170.339554	192.404143	190.226410

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
A	102.881736	111.686637	125.768067	135.008350	146.256339	164.018163	160.873214	181.621327	181.374539	195.252783
B	104.643103	120.539003	131.558259	130.746813	151.919901	155.166632	162.056039	183.869076	187.649126	208.370151
C	108.179150	115.920925	130.148913	136.241632	142.379800	161.175068	169.736229	175.752240	195.241157	203.594022
D	106.809360	114.649024	120.845874	132.234681	145.526677	164.945085	160.749303	184.553126	182.148298	200.637020
E	103.622581	110.578896	126.619778	138.689920	151.376287	154.760999	169.530191	172.488564	193.210322	203.421211

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
count	20.000000	20.000000	20.000000	20.000000	20.000000	20.000000	20.000000	20.000000	20.000000	20.000000
mean	104.000977	115.895242	126.317073	136.493366	147.912392	159.089417	167.402623	178.159948	190.404263	199.786777
std	2.510783	3.828523	3.759722	3.659154	3.772536	4.088436	5.299592	4.551163	4.865077	4.573630
min	100.234149	110.578896	120.133194	130.746813	140.521928	152.361455	160.401945	170.339554	181.374539	190.226410
25%	101.993175	111.752616	124.055720	133.733610	144.391453	155.150490	162.125471	174.981971	187.059540	196.581193
50%	104.059691	116.539419	126.119910	135.731316	149.240400	158.886989	168.419213	178.767835	190.927000	199.193332
75%	105.917770	119.330005	130.003792	139.584605	151.305271	162.606381	171.352049	181.618610	193.705424	202.755579
max	108.179150	120.691388	131.967359	142.015991	152.557097	164.945085	175.752172	185.712803	197.630924	208.645578

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
A	102.881736	111.686637	125.768067	135.008350	146.256339	164.018163	160.873214	181.621327	181.374539	195.252783
E	103.622581	110.578896	126.619778	138.689920	151.376287	154.760999	169.530191	172.488564	193.210322	203.421211
H	100.903158	119.322304	124.330644	141.522500	151.311206	152.361455	175.752172	178.327134	191.671344	194.948743
I	102.998368	114.514920	125.796594	138.064040	152.328394	158.786569	164.540042	181.894790	192.609703	202.533701
N	101.402427	111.520606	128.514006	140.518595	143.770781	157.809266	168.588914	180.942099	185.290782	197.464044
O	102.190091	111.005516	123.230949	133.121732	140.521928	160.917509	173.708382	181.617705	197.630924	198.788927
P	103.973501	112.693003	125.325745	141.575813	149.185102	155.102063	168.249512	171.706624	193.119364	198.662881
Q	100.632228	111.774609	131.967359	133.780612	151.303292	164.480898	160.401945	179.886245	188.566514	199.597736
R	100.355248	120.428993	124.964826	133.592602	144.556759	164.274347	164.397666	177.254149	184.947193	197.488116
S	100.234149	120.691388	121.844195	131.378565	149.295697	163.977574	163.239052	179.250700	189.277920	204.305453

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
categories
cat1	307.251076	353.026677	373.944748	407.175168	451.248836	487.445880	485.789612	537.009350	573.035163	605.079943
cat2	422.442197	462.680650	497.323294	542.348786	580.380825	641.376778	672.850987	719.819467	749.084130	790.999197
cat3	618.958830	691.204890	757.395457	816.574515	879.013414	956.606237	1014.331996	1058.767930	1143.483533	1205.151055
cat4	731.367432	810.992626	897.677966	963.768851	1047.604763	1096.359437	1175.079861	1247.602221	1342.482444	1394.505353

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
categories
cat1	102.417025	117.675559	124.648249	135.725056	150.416279	162.481960	161.929871	179.003117	191.011721	201.693314
cat2	105.610549	115.670162	124.330823	135.587196	145.095206	160.344195	168.212747	179.954867	187.271032	197.749799
cat3	103.159805	115.200815	126.232576	136.095753	146.502236	159.434373	169.055333	176.461322	190.580589	200.858509
cat4	104.481062	115.856089	128.239709	137.681264	149.657823	156.622777	167.868552	178.228889	191.783206	199.215050

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
categories
cat1	3.441866	5.110790	6.396007	5.578921	1.023975	3.036816	1.431147	1.029496	3.636565	2.395992
cat2	2.872337	3.368433	4.313997	3.519601	1.608163	3.908870	5.367796	3.919740	6.566091	1.995092
cat3	1.835640	4.570585	2.372080	3.303227	4.639601	4.300723	5.480003	4.489684	6.389855	4.790764
cat4	2.263351	3.539026	2.964713	3.753864	3.393915	3.575316	5.515933	5.946771	2.445981	6.090735

	name_	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9	categories	months
time
2001-01-01 00:00:00	A	102.881736	111.686637	125.768067	135.008350	146.256339	164.018163	160.873214	181.621327	181.374539	195.252783	cat3	Jan
2001-01-01 00:01:00	B	104.643103	120.539003	131.558259	130.746813	151.919901	155.166632	162.056039	183.869076	187.649126	208.370151	cat4	Feb
2001-01-01 00:02:00	C	108.179150	115.920925	130.148913	136.241632	142.379800	161.175068	169.736229	175.752240	195.241157	203.594022	cat4	Mar
2001-01-01 00:03:00	D	106.809360	114.649024	120.845874	132.234681	145.526677	164.945085	160.749303	184.553126	182.148298	200.637020	cat2	Apr
2001-01-01 00:04:00	E	103.622581	110.578896	126.619778	138.689920	151.376287	154.760999	169.530191	172.488564	193.210322	203.421211	cat3	Jan
2001-01-01 00:05:00	F	104.936108	110.646026	130.562393	139.273275	150.599323	153.104681	161.397454	185.712803	189.787608	196.169446	cat4	Feb
2001-01-01 00:06:00	G	106.384699	120.560680	120.133194	142.015991	150.649846	158.987409	162.148615	177.872405	195.190730	201.176754	cat1	Mar
2001-01-01 00:07:00	H	100.903158	119.322304	124.330644	141.522500	151.311206	152.361455	175.752172	178.327134	191.671344	194.948743	cat4	Apr
2001-01-01 00:08:00	I	102.998368	114.514920	125.796594	138.064040	152.328394	158.786569	164.540042	181.894790	192.609703	202.533701	cat4	Jan
2001-01-01 00:09:00	J	106.381198	117.157913	127.583377	134.374511	147.187832	156.473112	170.101022	179.208536	184.741790	196.184813	cat2	Feb
2001-01-01 00:10:00	K	105.763294	118.215099	126.443226	134.642078	143.745005	157.830239	175.135949	171.205422	190.182657	201.554441	cat3	Mar
2001-01-01 00:11:00	L	104.145880	119.289749	130.368611	141.519833	152.557097	154.804981	170.686594	174.580763	196.137898	208.645578	cat3	Apr
2001-01-01 00:12:00	M	107.849212	119.353107	120.380036	135.220999	143.895535	162.149316	173.411748	175.115706	196.903260	196.713319	cat2	Jan
2001-01-01 00:13:00	N	101.402427	111.520606	128.514006	140.518595	143.770781	157.809266	168.588914	180.942099	185.290782	197.464044	cat2	Feb
2001-01-01 00:14:00	O	102.190091	111.005516	123.230949	133.121732	140.521928	160.917509	173.708382	181.617705	197.630924	198.788927	cat3	Mar
2001-01-01 00:15:00	P	103.973501	112.693003	125.325745	141.575813	149.185102	155.102063	168.249512	171.706624	193.119364	198.662881	cat4	Apr
2001-01-01 00:16:00	Q	100.632228	111.774609	131.967359	133.780612	151.303292	164.480898	160.401945	179.886245	188.566514	199.597736	cat1	Jan
2001-01-01 00:17:00	R	100.355248	120.428993	124.964826	133.592602	144.556759	164.274347	164.397666	177.254149	184.947193	197.488116	cat3	Feb
2001-01-01 00:18:00	S	100.234149	120.691388	121.844195	131.378565	149.295697	163.977574	163.239052	179.250700	189.277920	204.305453	cat1	Mar
2001-01-01 00:19:00	T	105.734044	117.356446	129.955418	136.344778	149.881037	160.662969	173.348414	170.339554	192.404143	190.226410	cat4	Apr

	col0	col1	col2	col3	col4	col5	col6	col7	col8	col9
time
2001-01-01 00:00:00	105.227186	114.674897	126.988178	134.584279	147.491801	160.013189	164.588995	179.656866	187.924688	202.255037
2001-01-01 00:05:00	104.320706	116.440369	125.681240	139.050063	150.415320	155.942645	166.787861	180.603133	190.800235	198.202691
2001-01-01 00:10:00	104.270181	115.876815	125.787366	137.004648	144.898069	158.702262	172.306317	176.692339	193.229104	200.633262
2001-01-01 00:15:00	102.185834	116.588888	126.811509	135.334474	148.844377	161.699570	165.927318	175.687455	189.663027	198.056119

	Unnamed: 0	city	month	year	maxtemp	mintemp	rainfall
0	0	HYDERABAD	January	1951	29.0	14.8	0.0
1	1	HYDERABAD	January	1952	29.1	13.6	0.0
2	2	HYDERABAD	January	1953	28.6	14.6	3.5
3	3	HYDERABAD	January	1954	28.2	13.9	0.0
4	4	HYDERABAD	January	1955	28.0	14.7	0.0