In [1]:

    

from IPython.display import Image


    

In [2]:

    

Image(url='https://media.licdn.com/media/p/3/005/01f/03d/09e93bc.jpg')


    

    
Out[2]:

In [5]:

    

Image(url='http://akamaicovers.oreilly.com/images/0636920023784/lrg.jpg')


    

    
Out[5]:

In [6]:

    

Image(url='https://scontent.xx.fbcdn.net/hphotos-xat1/t31.0-8/12977189_1718821025046776_8277322074510590447_o.png')


    

    
Out[6]:

In [7]:

    

Image(url='https://scontent.xx.fbcdn.net/hphotos-xpf1/t31.0-8/12970979_1718821051713440_6403705471788355661_o.jpg')


    

    
Out[7]:

In [10]:

    

Image(url='http://www.data-warehouse.com.au/Images/Site/Data-Warehouse_Architecture_Simple_1200px.jpg')


    

    
Out[10]:

In [9]:

    

Image(url='http://www.dwknowledgehub.com/wp-content/uploads/2015/05/2_tier_architecture-dependent-datamart.png')


    

    
Out[9]:

In [12]:

    

Image(url='http://docs.aws.amazon.com/ko_kr/datapipeline/latest/DeveloperGuide/images/dp-how-dp-works-v2.png')


    

    
Out[12]:

In [11]:

    

Image(filename='images/visualization.png')


    

    
Out[11]:

In [3]:

    

import numpy as np


    

In [31]:

    

data = [1, 2, 3, 4]  # 리스트
arr = np.array(data)
arr


    

    
Out[31]:





array([1, 2, 3, 4])

In [10]:

    

type(np)


    

    
Out[10]:





module

In [14]:

    

type(np.array)


    

    
Out[14]:





builtin_function_or_method

In [18]:

    

help(np.array)


    

    




Help on built-in function array in module numpy.core.multiarray:

array(...)
    array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
    
    Create an array.
    
    Parameters
    ----------
    object : array_like
        An array, any object exposing the array interface, an
        object whose __array__ method returns an array, or any
        (nested) sequence.
    dtype : data-type, optional
        The desired data-type for the array.  If not given, then
        the type will be determined as the minimum type required
        to hold the objects in the sequence.  This argument can only
        be used to 'upcast' the array.  For downcasting, use the
        .astype(t) method.
    copy : bool, optional
        If true (default), then the object is copied.  Otherwise, a copy
        will only be made if __array__ returns a copy, if obj is a
        nested sequence, or if a copy is needed to satisfy any of the other
        requirements (`dtype`, `order`, etc.).
    order : {'C', 'F', 'A'}, optional
        Specify the order of the array.  If order is 'C', then the array
        will be in C-contiguous order (last-index varies the fastest).
        If order is 'F', then the returned array will be in
        Fortran-contiguous order (first-index varies the fastest).
        If order is 'A' (default), then the returned array may be
        in any order (either C-, Fortran-contiguous, or even discontiguous),
        unless a copy is required, in which case it will be C-contiguous.
    subok : bool, optional
        If True, then sub-classes will be passed-through, otherwise
        the returned array will be forced to be a base-class array (default).
    ndmin : int, optional
        Specifies the minimum number of dimensions that the resulting
        array should have.  Ones will be pre-pended to the shape as
        needed to meet this requirement.
    
    Returns
    -------
    out : ndarray
        An array object satisfying the specified requirements.
    
    See Also
    --------
    empty, empty_like, zeros, zeros_like, ones, ones_like, fill
    
    Examples
    --------
    >>> np.array([1, 2, 3])
    array([1, 2, 3])
    
    Upcasting:
    
    >>> np.array([1, 2, 3.0])
    array([ 1.,  2.,  3.])
    
    More than one dimension:
    
    >>> np.array([[1, 2], [3, 4]])
    array([[1, 2],
           [3, 4]])
    
    Minimum dimensions 2:
    
    >>> np.array([1, 2, 3], ndmin=2)
    array([[1, 2, 3]])
    
    Type provided:
    
    >>> np.array([1, 2, 3], dtype=complex)
    array([ 1.+0.j,  2.+0.j,  3.+0.j])
    
    Data-type consisting of more than one element:
    
    >>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
    >>> x['a']
    array([1, 3])
    
    Creating an array from sub-classes:
    
    >>> np.array(np.mat('1 2; 3 4'))
    array([[1, 2],
           [3, 4]])
    
    >>> np.array(np.mat('1 2; 3 4'), subok=True)
    matrix([[1, 2],
            [3, 4]])

In [43]:

    

type(arr)


    

    
Out[43]:





numpy.ndarray

In [46]:

    

help(arr)


    

    




Help on ndarray object:

class ndarray(builtins.object)
 |  ndarray(shape, dtype=float, buffer=None, offset=0,
 |          strides=None, order=None)
 |  
 |  An array object represents a multidimensional, homogeneous array
 |  of fixed-size items.  An associated data-type object describes the
 |  format of each element in the array (its byte-order, how many bytes it
 |  occupies in memory, whether it is an integer, a floating point number,
 |  or something else, etc.)
 |  
 |  Arrays should be constructed using `array`, `zeros` or `empty` (refer
 |  to the See Also section below).  The parameters given here refer to
 |  a low-level method (`ndarray(...)`) for instantiating an array.
 |  
 |  For more information, refer to the `numpy` module and examine the
 |  the methods and attributes of an array.
 |  
 |  Parameters
 |  ----------
 |  (for the __new__ method; see Notes below)
 |  
 |  shape : tuple of ints
 |      Shape of created array.
 |  dtype : data-type, optional
 |      Any object that can be interpreted as a numpy data type.
 |  buffer : object exposing buffer interface, optional
 |      Used to fill the array with data.
 |  offset : int, optional
 |      Offset of array data in buffer.
 |  strides : tuple of ints, optional
 |      Strides of data in memory.
 |  order : {'C', 'F'}, optional
 |      Row-major (C-style) or column-major (Fortran-style) order.
 |  
 |  Attributes
 |  ----------
 |  T : ndarray
 |      Transpose of the array.
 |  data : buffer
 |      The array's elements, in memory.
 |  dtype : dtype object
 |      Describes the format of the elements in the array.
 |  flags : dict
 |      Dictionary containing information related to memory use, e.g.,
 |      'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
 |  flat : numpy.flatiter object
 |      Flattened version of the array as an iterator.  The iterator
 |      allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
 |      assignment examples; TODO).
 |  imag : ndarray
 |      Imaginary part of the array.
 |  real : ndarray
 |      Real part of the array.
 |  size : int
 |      Number of elements in the array.
 |  itemsize : int
 |      The memory use of each array element in bytes.
 |  nbytes : int
 |      The total number of bytes required to store the array data,
 |      i.e., ``itemsize * size``.
 |  ndim : int
 |      The array's number of dimensions.
 |  shape : tuple of ints
 |      Shape of the array.
 |  strides : tuple of ints
 |      The step-size required to move from one element to the next in
 |      memory. For example, a contiguous ``(3, 4)`` array of type
 |      ``int16`` in C-order has strides ``(8, 2)``.  This implies that
 |      to move from element to element in memory requires jumps of 2 bytes.
 |      To move from row-to-row, one needs to jump 8 bytes at a time
 |      (``2 * 4``).
 |  ctypes : ctypes object
 |      Class containing properties of the array needed for interaction
 |      with ctypes.
 |  base : ndarray
 |      If the array is a view into another array, that array is its `base`
 |      (unless that array is also a view).  The `base` array is where the
 |      array data is actually stored.
 |  
 |  See Also
 |  --------
 |  array : Construct an array.
 |  zeros : Create an array, each element of which is zero.
 |  empty : Create an array, but leave its allocated memory unchanged (i.e.,
 |          it contains "garbage").
 |  dtype : Create a data-type.
 |  
 |  Notes
 |  -----
 |  There are two modes of creating an array using ``__new__``:
 |  
 |  1. If `buffer` is None, then only `shape`, `dtype`, and `order`
 |     are used.
 |  2. If `buffer` is an object exposing the buffer interface, then
 |     all keywords are interpreted.
 |  
 |  No ``__init__`` method is needed because the array is fully initialized
 |  after the ``__new__`` method.
 |  
 |  Examples
 |  --------
 |  These examples illustrate the low-level `ndarray` constructor.  Refer
 |  to the `See Also` section above for easier ways of constructing an
 |  ndarray.
 |  
 |  First mode, `buffer` is None:
 |  
 |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')
 |  array([[ -1.13698227e+002,   4.25087011e-303],
 |         [  2.88528414e-306,   3.27025015e-309]])         #random
 |  
 |  Second mode:
 |  
 |  >>> np.ndarray((2,), buffer=np.array([1,2,3]),
 |  ...            offset=np.int_().itemsize,
 |  ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
 |  array([2, 3])
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__([order])
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A'}, optional
 |          If order is 'C' (False) then the result is contiguous (default).
 |          If order is 'Fortran' (True) then the result has fortran order.
 |          If order is 'Any' (None) then the result has fortran order
 |          only if the array already is in fortran order.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__() -> Deep copy of array.
 |      
 |      Used if copy.deepcopy is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(version, shape, dtype, isfortran, rawdata)
 |      
 |      For unpickling.
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:numpy.copy are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(a, 3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE
 |      can only be set to True if the array owns its own memory, or the
 |      ultimate owner of the memory exposes a writeable buffer interface,
 |      or is a string. (The exception for string is made so that unpickling
 |      can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another "base" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 6 Boolean flags
 |      in use, only three of which can be changed by the user:
 |      UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) this array is a copy of some other array (referenced
 |      by .base). When this array is deallocated, the base array will be
 |      updated with the contents of this array.
 |      
 |      All flags can be accessed using their first (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: cannot set UPDATEIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="", format="%s")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If "" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using "format" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a "convenience" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in "Guide to NumPy" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      UPDATEIFCOPY (U)
 |          This array is a copy of some other array. When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
 |      the user, via direct assignment to the attribute or dictionary entry,
 |      or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      Notes
 |      -----
 |      May be used to "reshape" the array, as long as this would not
 |      require a change in the total number of elements
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      "ndarray.rst" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      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]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

In [44]:

    

dir(arr)


    

    
Out[44]:





['T',
 '__abs__',
 '__add__',
 '__and__',
 '__array__',
 '__array_finalize__',
 '__array_interface__',
 '__array_prepare__',
 '__array_priority__',
 '__array_struct__',
 '__array_wrap__',
 '__bool__',
 '__class__',
 '__contains__',
 '__copy__',
 '__deepcopy__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__iand__',
 '__ifloordiv__',
 '__ilshift__',
 '__imatmul__',
 '__imod__',
 '__imul__',
 '__index__',
 '__init__',
 '__int__',
 '__invert__',
 '__ior__',
 '__ipow__',
 '__irshift__',
 '__isub__',
 '__iter__',
 '__itruediv__',
 '__ixor__',
 '__le__',
 '__len__',
 '__lshift__',
 '__lt__',
 '__matmul__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__or__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rlshift__',
 '__rmatmul__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__rpow__',
 '__rrshift__',
 '__rshift__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__setattr__',
 '__setitem__',
 '__setstate__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__xor__',
 'all',
 'any',
 'argmax',
 'argmin',
 'argpartition',
 'argsort',
 'astype',
 'base',
 'byteswap',
 'choose',
 'clip',
 'compress',
 'conj',
 'conjugate',
 'copy',
 'ctypes',
 'cumprod',
 'cumsum',
 'data',
 'diagonal',
 'dot',
 'dtype',
 'dump',
 'dumps',
 'fill',
 'flags',
 'flat',
 'flatten',
 'getfield',
 'imag',
 'item',
 'itemset',
 'itemsize',
 'max',
 'mean',
 'min',
 'nbytes',
 'ndim',
 'newbyteorder',
 'nonzero',
 'partition',
 'prod',
 'ptp',
 'put',
 'ravel',
 'real',
 'repeat',
 'reshape',
 'resize',
 'round',
 'searchsorted',
 'setfield',
 'setflags',
 'shape',
 'size',
 'sort',
 'squeeze',
 'std',
 'strides',
 'sum',
 'swapaxes',
 'take',
 'tobytes',
 'tofile',
 'tolist',
 'tostring',
 'trace',
 'transpose',
 'var',
 'view']

In [47]:

    

data = (1, 2, 3, 4)  # 튜플
arr = np.array(data)
arr


    

    
Out[47]:





array([1, 2, 3, 4])

In [49]:

    

help(arr)


    

    




Help on ndarray object:

class ndarray(builtins.object)
 |  ndarray(shape, dtype=float, buffer=None, offset=0,
 |          strides=None, order=None)
 |  
 |  An array object represents a multidimensional, homogeneous array
 |  of fixed-size items.  An associated data-type object describes the
 |  format of each element in the array (its byte-order, how many bytes it
 |  occupies in memory, whether it is an integer, a floating point number,
 |  or something else, etc.)
 |  
 |  Arrays should be constructed using `array`, `zeros` or `empty` (refer
 |  to the See Also section below).  The parameters given here refer to
 |  a low-level method (`ndarray(...)`) for instantiating an array.
 |  
 |  For more information, refer to the `numpy` module and examine the
 |  the methods and attributes of an array.
 |  
 |  Parameters
 |  ----------
 |  (for the __new__ method; see Notes below)
 |  
 |  shape : tuple of ints
 |      Shape of created array.
 |  dtype : data-type, optional
 |      Any object that can be interpreted as a numpy data type.
 |  buffer : object exposing buffer interface, optional
 |      Used to fill the array with data.
 |  offset : int, optional
 |      Offset of array data in buffer.
 |  strides : tuple of ints, optional
 |      Strides of data in memory.
 |  order : {'C', 'F'}, optional
 |      Row-major (C-style) or column-major (Fortran-style) order.
 |  
 |  Attributes
 |  ----------
 |  T : ndarray
 |      Transpose of the array.
 |  data : buffer
 |      The array's elements, in memory.
 |  dtype : dtype object
 |      Describes the format of the elements in the array.
 |  flags : dict
 |      Dictionary containing information related to memory use, e.g.,
 |      'C_CONTIGUOUS', 'OWNDATA', 'WRITEABLE', etc.
 |  flat : numpy.flatiter object
 |      Flattened version of the array as an iterator.  The iterator
 |      allows assignments, e.g., ``x.flat = 3`` (See `ndarray.flat` for
 |      assignment examples; TODO).
 |  imag : ndarray
 |      Imaginary part of the array.
 |  real : ndarray
 |      Real part of the array.
 |  size : int
 |      Number of elements in the array.
 |  itemsize : int
 |      The memory use of each array element in bytes.
 |  nbytes : int
 |      The total number of bytes required to store the array data,
 |      i.e., ``itemsize * size``.
 |  ndim : int
 |      The array's number of dimensions.
 |  shape : tuple of ints
 |      Shape of the array.
 |  strides : tuple of ints
 |      The step-size required to move from one element to the next in
 |      memory. For example, a contiguous ``(3, 4)`` array of type
 |      ``int16`` in C-order has strides ``(8, 2)``.  This implies that
 |      to move from element to element in memory requires jumps of 2 bytes.
 |      To move from row-to-row, one needs to jump 8 bytes at a time
 |      (``2 * 4``).
 |  ctypes : ctypes object
 |      Class containing properties of the array needed for interaction
 |      with ctypes.
 |  base : ndarray
 |      If the array is a view into another array, that array is its `base`
 |      (unless that array is also a view).  The `base` array is where the
 |      array data is actually stored.
 |  
 |  See Also
 |  --------
 |  array : Construct an array.
 |  zeros : Create an array, each element of which is zero.
 |  empty : Create an array, but leave its allocated memory unchanged (i.e.,
 |          it contains "garbage").
 |  dtype : Create a data-type.
 |  
 |  Notes
 |  -----
 |  There are two modes of creating an array using ``__new__``:
 |  
 |  1. If `buffer` is None, then only `shape`, `dtype`, and `order`
 |     are used.
 |  2. If `buffer` is an object exposing the buffer interface, then
 |     all keywords are interpreted.
 |  
 |  No ``__init__`` method is needed because the array is fully initialized
 |  after the ``__new__`` method.
 |  
 |  Examples
 |  --------
 |  These examples illustrate the low-level `ndarray` constructor.  Refer
 |  to the `See Also` section above for easier ways of constructing an
 |  ndarray.
 |  
 |  First mode, `buffer` is None:
 |  
 |  >>> np.ndarray(shape=(2,2), dtype=float, order='F')
 |  array([[ -1.13698227e+002,   4.25087011e-303],
 |         [  2.88528414e-306,   3.27025015e-309]])         #random
 |  
 |  Second mode:
 |  
 |  >>> np.ndarray((2,), buffer=np.array([1,2,3]),
 |  ...            offset=np.int_().itemsize,
 |  ...            dtype=int) # offset = 1*itemsize, i.e. skip first element
 |  array([2, 3])
 |  
 |  Methods defined here:
 |  
 |  __abs__(self, /)
 |      abs(self)
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __and__(self, value, /)
 |      Return self&value.
 |  
 |  __array__(...)
 |      a.__array__(|dtype) -> reference if type unchanged, copy otherwise.
 |      
 |      Returns either a new reference to self if dtype is not given or a new array
 |      of provided data type if dtype is different from the current dtype of the
 |      array.
 |  
 |  __array_prepare__(...)
 |      a.__array_prepare__(obj) -> Object of same type as ndarray object obj.
 |  
 |  __array_wrap__(...)
 |      a.__array_wrap__(obj) -> Object of same type as ndarray object a.
 |  
 |  __bool__(self, /)
 |      self != 0
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __copy__(...)
 |      a.__copy__([order])
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A'}, optional
 |          If order is 'C' (False) then the result is contiguous (default).
 |          If order is 'Fortran' (True) then the result has fortran order.
 |          If order is 'Any' (None) then the result has fortran order
 |          only if the array already is in fortran order.
 |  
 |  __deepcopy__(...)
 |      a.__deepcopy__() -> Deep copy of array.
 |      
 |      Used if copy.deepcopy is called on an array.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __divmod__(self, value, /)
 |      Return divmod(self, value).
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __float__(self, /)
 |      float(self)
 |  
 |  __floordiv__(self, value, /)
 |      Return self//value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getitem__(self, key, /)
 |      Return self[key].
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Return self+=value.
 |  
 |  __iand__(self, value, /)
 |      Return self&=value.
 |  
 |  __ifloordiv__(self, value, /)
 |      Return self//=value.
 |  
 |  __ilshift__(self, value, /)
 |      Return self<<=value.
 |  
 |  __imatmul__(self, value, /)
 |      Return self@=value.
 |  
 |  __imod__(self, value, /)
 |      Return self%=value.
 |  
 |  __imul__(self, value, /)
 |      Return self*=value.
 |  
 |  __index__(self, /)
 |      Return self converted to an integer, if self is suitable for use as an index into a list.
 |  
 |  __int__(self, /)
 |      int(self)
 |  
 |  __invert__(self, /)
 |      ~self
 |  
 |  __ior__(self, value, /)
 |      Return self|=value.
 |  
 |  __ipow__(self, value, /)
 |      Return self**=value.
 |  
 |  __irshift__(self, value, /)
 |      Return self>>=value.
 |  
 |  __isub__(self, value, /)
 |      Return self-=value.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __itruediv__(self, value, /)
 |      Return self/=value.
 |  
 |  __ixor__(self, value, /)
 |      Return self^=value.
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lshift__(self, value, /)
 |      Return self<<value.
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __matmul__(self, value, /)
 |      Return self@value.
 |  
 |  __mod__(self, value, /)
 |      Return self%value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __neg__(self, /)
 |      -self
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __or__(self, value, /)
 |      Return self|value.
 |  
 |  __pos__(self, /)
 |      +self
 |  
 |  __pow__(self, value, mod=None, /)
 |      Return pow(self, value, mod).
 |  
 |  __radd__(self, value, /)
 |      Return value+self.
 |  
 |  __rand__(self, value, /)
 |      Return value&self.
 |  
 |  __rdivmod__(self, value, /)
 |      Return divmod(value, self).
 |  
 |  __reduce__(...)
 |      a.__reduce__()
 |      
 |      For pickling.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __rfloordiv__(self, value, /)
 |      Return value//self.
 |  
 |  __rlshift__(self, value, /)
 |      Return value<<self.
 |  
 |  __rmatmul__(self, value, /)
 |      Return value@self.
 |  
 |  __rmod__(self, value, /)
 |      Return value%self.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __ror__(self, value, /)
 |      Return value|self.
 |  
 |  __rpow__(self, value, mod=None, /)
 |      Return pow(value, self, mod).
 |  
 |  __rrshift__(self, value, /)
 |      Return value>>self.
 |  
 |  __rshift__(self, value, /)
 |      Return self>>value.
 |  
 |  __rsub__(self, value, /)
 |      Return value-self.
 |  
 |  __rtruediv__(self, value, /)
 |      Return value/self.
 |  
 |  __rxor__(self, value, /)
 |      Return value^self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __setstate__(...)
 |      a.__setstate__(version, shape, dtype, isfortran, rawdata)
 |      
 |      For unpickling.
 |      
 |      Parameters
 |      ----------
 |      version : int
 |          optional pickle version. If omitted defaults to 0.
 |      shape : tuple
 |      dtype : data-type
 |      isFortran : bool
 |      rawdata : string or list
 |          a binary string with the data (or a list if 'a' is an object array)
 |  
 |  __sizeof__(...)
 |      __sizeof__() -> int
 |      size of object in memory, in bytes
 |  
 |  __str__(self, /)
 |      Return str(self).
 |  
 |  __sub__(self, value, /)
 |      Return self-value.
 |  
 |  __truediv__(self, value, /)
 |      Return self/value.
 |  
 |  __xor__(self, value, /)
 |      Return self^value.
 |  
 |  all(...)
 |      a.all(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if all elements evaluate to True.
 |      
 |      Refer to `numpy.all` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.all : equivalent function
 |  
 |  any(...)
 |      a.any(axis=None, out=None, keepdims=False)
 |      
 |      Returns True if any of the elements of `a` evaluate to True.
 |      
 |      Refer to `numpy.any` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.any : equivalent function
 |  
 |  argmax(...)
 |      a.argmax(axis=None, out=None)
 |      
 |      Return indices of the maximum values along the given axis.
 |      
 |      Refer to `numpy.argmax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmax : equivalent function
 |  
 |  argmin(...)
 |      a.argmin(axis=None, out=None)
 |      
 |      Return indices of the minimum values along the given axis of `a`.
 |      
 |      Refer to `numpy.argmin` for detailed documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argmin : equivalent function
 |  
 |  argpartition(...)
 |      a.argpartition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Returns the indices that would partition this array.
 |      
 |      Refer to `numpy.argpartition` for full documentation.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      See Also
 |      --------
 |      numpy.argpartition : equivalent function
 |  
 |  argsort(...)
 |      a.argsort(axis=-1, kind='quicksort', order=None)
 |      
 |      Returns the indices that would sort this array.
 |      
 |      Refer to `numpy.argsort` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.argsort : equivalent function
 |  
 |  astype(...)
 |      a.astype(dtype, order='K', casting='unsafe', subok=True, copy=True)
 |      
 |      Copy of the array, cast to a specified type.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          Typecode or data-type to which the array is cast.
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout order of the result.
 |          'C' means C order, 'F' means Fortran order, 'A'
 |          means 'F' order if all the arrays are Fortran contiguous,
 |          'C' order otherwise, and 'K' means as close to the
 |          order the array elements appear in memory as possible.
 |          Default is 'K'.
 |      casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
 |          Controls what kind of data casting may occur. Defaults to 'unsafe'
 |          for backwards compatibility.
 |      
 |            * 'no' means the data types should not be cast at all.
 |            * 'equiv' means only byte-order changes are allowed.
 |            * 'safe' means only casts which can preserve values are allowed.
 |            * 'same_kind' means only safe casts or casts within a kind,
 |              like float64 to float32, are allowed.
 |            * 'unsafe' means any data conversions may be done.
 |      subok : bool, optional
 |          If True, then sub-classes will be passed-through (default), otherwise
 |          the returned array will be forced to be a base-class array.
 |      copy : bool, optional
 |          By default, astype always returns a newly allocated array. If this
 |          is set to false, and the `dtype`, `order`, and `subok`
 |          requirements are satisfied, the input array is returned instead
 |          of a copy.
 |      
 |      Returns
 |      -------
 |      arr_t : ndarray
 |          Unless `copy` is False and the other conditions for returning the input
 |          array are satisfied (see description for `copy` input parameter), `arr_t`
 |          is a new array of the same shape as the input array, with dtype, order
 |          given by `dtype`, `order`.
 |      
 |      Notes
 |      -----
 |      Starting in NumPy 1.9, astype method now returns an error if the string
 |      dtype to cast to is not long enough in 'safe' casting mode to hold the max
 |      value of integer/float array that is being casted. Previously the casting
 |      was allowed even if the result was truncated.
 |      
 |      Raises
 |      ------
 |      ComplexWarning
 |          When casting from complex to float or int. To avoid this,
 |          one should use ``a.real.astype(t)``.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 2.5])
 |      >>> x
 |      array([ 1. ,  2. ,  2.5])
 |      
 |      >>> x.astype(int)
 |      array([1, 2, 2])
 |  
 |  byteswap(...)
 |      a.byteswap(inplace)
 |      
 |      Swap the bytes of the array elements
 |      
 |      Toggle between low-endian and big-endian data representation by
 |      returning a byteswapped array, optionally swapped in-place.
 |      
 |      Parameters
 |      ----------
 |      inplace : bool, optional
 |          If ``True``, swap bytes in-place, default is ``False``.
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          The byteswapped array. If `inplace` is ``True``, this is
 |          a view to self.
 |      
 |      Examples
 |      --------
 |      >>> A = np.array([1, 256, 8755], dtype=np.int16)
 |      >>> map(hex, A)
 |      ['0x1', '0x100', '0x2233']
 |      >>> A.byteswap(True)
 |      array([  256,     1, 13090], dtype=int16)
 |      >>> map(hex, A)
 |      ['0x100', '0x1', '0x3322']
 |      
 |      Arrays of strings are not swapped
 |      
 |      >>> A = np.array(['ceg', 'fac'])
 |      >>> A.byteswap()
 |      array(['ceg', 'fac'],
 |            dtype='|S3')
 |  
 |  choose(...)
 |      a.choose(choices, out=None, mode='raise')
 |      
 |      Use an index array to construct a new array from a set of choices.
 |      
 |      Refer to `numpy.choose` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.choose : equivalent function
 |  
 |  clip(...)
 |      a.clip(min=None, max=None, out=None)
 |      
 |      Return an array whose values are limited to ``[min, max]``.
 |      One of max or min must be given.
 |      
 |      Refer to `numpy.clip` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.clip : equivalent function
 |  
 |  compress(...)
 |      a.compress(condition, axis=None, out=None)
 |      
 |      Return selected slices of this array along given axis.
 |      
 |      Refer to `numpy.compress` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.compress : equivalent function
 |  
 |  conj(...)
 |      a.conj()
 |      
 |      Complex-conjugate all elements.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  conjugate(...)
 |      a.conjugate()
 |      
 |      Return the complex conjugate, element-wise.
 |      
 |      Refer to `numpy.conjugate` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.conjugate : equivalent function
 |  
 |  copy(...)
 |      a.copy(order='C')
 |      
 |      Return a copy of the array.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          Controls the memory layout of the copy. 'C' means C-order,
 |          'F' means F-order, 'A' means 'F' if `a` is Fortran contiguous,
 |          'C' otherwise. 'K' means match the layout of `a` as closely
 |          as possible. (Note that this function and :func:numpy.copy are very
 |          similar, but have different default values for their order=
 |          arguments.)
 |      
 |      See also
 |      --------
 |      numpy.copy
 |      numpy.copyto
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1,2,3],[4,5,6]], order='F')
 |      
 |      >>> y = x.copy()
 |      
 |      >>> x.fill(0)
 |      
 |      >>> x
 |      array([[0, 0, 0],
 |             [0, 0, 0]])
 |      
 |      >>> y
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      
 |      >>> y.flags['C_CONTIGUOUS']
 |      True
 |  
 |  cumprod(...)
 |      a.cumprod(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative product of the elements along the given axis.
 |      
 |      Refer to `numpy.cumprod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumprod : equivalent function
 |  
 |  cumsum(...)
 |      a.cumsum(axis=None, dtype=None, out=None)
 |      
 |      Return the cumulative sum of the elements along the given axis.
 |      
 |      Refer to `numpy.cumsum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.cumsum : equivalent function
 |  
 |  diagonal(...)
 |      a.diagonal(offset=0, axis1=0, axis2=1)
 |      
 |      Return specified diagonals. In NumPy 1.9 the returned array is a
 |      read-only view instead of a copy as in previous NumPy versions.  In
 |      a future version the read-only restriction will be removed.
 |      
 |      Refer to :func:`numpy.diagonal` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.diagonal : equivalent function
 |  
 |  dot(...)
 |      a.dot(b, out=None)
 |      
 |      Dot product of two arrays.
 |      
 |      Refer to `numpy.dot` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.dot : equivalent function
 |      
 |      Examples
 |      --------
 |      >>> a = np.eye(2)
 |      >>> b = np.ones((2, 2)) * 2
 |      >>> a.dot(b)
 |      array([[ 2.,  2.],
 |             [ 2.,  2.]])
 |      
 |      This array method can be conveniently chained:
 |      
 |      >>> a.dot(b).dot(b)
 |      array([[ 8.,  8.],
 |             [ 8.,  8.]])
 |  
 |  dump(...)
 |      a.dump(file)
 |      
 |      Dump a pickle of the array to the specified file.
 |      The array can be read back with pickle.load or numpy.load.
 |      
 |      Parameters
 |      ----------
 |      file : str
 |          A string naming the dump file.
 |  
 |  dumps(...)
 |      a.dumps()
 |      
 |      Returns the pickle of the array as a string.
 |      pickle.loads or numpy.loads will convert the string back to an array.
 |      
 |      Parameters
 |      ----------
 |      None
 |  
 |  fill(...)
 |      a.fill(value)
 |      
 |      Fill the array with a scalar value.
 |      
 |      Parameters
 |      ----------
 |      value : scalar
 |          All elements of `a` will be assigned this value.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.fill(0)
 |      >>> a
 |      array([0, 0])
 |      >>> a = np.empty(2)
 |      >>> a.fill(1)
 |      >>> a
 |      array([ 1.,  1.])
 |  
 |  flatten(...)
 |      a.flatten(order='C')
 |      
 |      Return a copy of the array collapsed into one dimension.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', 'A', 'K'}, optional
 |          'C' means to flatten in row-major (C-style) order.
 |          'F' means to flatten in column-major (Fortran-
 |          style) order. 'A' means to flatten in column-major
 |          order if `a` is Fortran *contiguous* in memory,
 |          row-major order otherwise. 'K' means to flatten
 |          `a` in the order the elements occur in memory.
 |          The default is 'C'.
 |      
 |      Returns
 |      -------
 |      y : ndarray
 |          A copy of the input array, flattened to one dimension.
 |      
 |      See Also
 |      --------
 |      ravel : Return a flattened array.
 |      flat : A 1-D flat iterator over the array.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,2], [3,4]])
 |      >>> a.flatten()
 |      array([1, 2, 3, 4])
 |      >>> a.flatten('F')
 |      array([1, 3, 2, 4])
 |  
 |  getfield(...)
 |      a.getfield(dtype, offset=0)
 |      
 |      Returns a field of the given array as a certain type.
 |      
 |      A field is a view of the array data with a given data-type. The values in
 |      the view are determined by the given type and the offset into the current
 |      array in bytes. The offset needs to be such that the view dtype fits in the
 |      array dtype; for example an array of dtype complex128 has 16-byte elements.
 |      If taking a view with a 32-bit integer (4 bytes), the offset needs to be
 |      between 0 and 12 bytes.
 |      
 |      Parameters
 |      ----------
 |      dtype : str or dtype
 |          The data type of the view. The dtype size of the view can not be larger
 |          than that of the array itself.
 |      offset : int
 |          Number of bytes to skip before beginning the element view.
 |      
 |      Examples
 |      --------
 |      >>> x = np.diag([1.+1.j]*2)
 |      >>> x[1, 1] = 2 + 4.j
 |      >>> x
 |      array([[ 1.+1.j,  0.+0.j],
 |             [ 0.+0.j,  2.+4.j]])
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.],
 |             [ 0.,  2.]])
 |      
 |      By choosing an offset of 8 bytes we can select the complex part of the
 |      array for our view:
 |      
 |      >>> x.getfield(np.float64, offset=8)
 |      array([[ 1.,  0.],
 |         [ 0.,  4.]])
 |  
 |  item(...)
 |      a.item(*args)
 |      
 |      Copy an element of an array to a standard Python scalar and return it.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments (variable number and type)
 |      
 |          * none: in this case, the method only works for arrays
 |            with one element (`a.size == 1`), which element is
 |            copied into a standard Python scalar object and returned.
 |      
 |          * int_type: this argument is interpreted as a flat index into
 |            the array, specifying which element to copy and return.
 |      
 |          * tuple of int_types: functions as does a single int_type argument,
 |            except that the argument is interpreted as an nd-index into the
 |            array.
 |      
 |      Returns
 |      -------
 |      z : Standard Python scalar object
 |          A copy of the specified element of the array as a suitable
 |          Python scalar
 |      
 |      Notes
 |      -----
 |      When the data type of `a` is longdouble or clongdouble, item() returns
 |      a scalar array object because there is no available Python scalar that
 |      would not lose information. Void arrays return a buffer object for item(),
 |      unless fields are defined, in which case a tuple is returned.
 |      
 |      `item` is very similar to a[args], except, instead of an array scalar,
 |      a standard Python scalar is returned. This can be useful for speeding up
 |      access to elements of the array and doing arithmetic on elements of the
 |      array using Python's optimized math.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.item(3)
 |      2
 |      >>> x.item(7)
 |      5
 |      >>> x.item((0, 1))
 |      1
 |      >>> x.item((2, 2))
 |      3
 |  
 |  itemset(...)
 |      a.itemset(*args)
 |      
 |      Insert scalar into an array (scalar is cast to array's dtype, if possible)
 |      
 |      There must be at least 1 argument, and define the last argument
 |      as *item*.  Then, ``a.itemset(*args)`` is equivalent to but faster
 |      than ``a[args] = item``.  The item should be a scalar value and `args`
 |      must select a single item in the array `a`.
 |      
 |      Parameters
 |      ----------
 |      \*args : Arguments
 |          If one argument: a scalar, only used in case `a` is of size 1.
 |          If two arguments: the last argument is the value to be set
 |          and must be a scalar, the first argument specifies a single array
 |          element location. It is either an int or a tuple.
 |      
 |      Notes
 |      -----
 |      Compared to indexing syntax, `itemset` provides some speed increase
 |      for placing a scalar into a particular location in an `ndarray`,
 |      if you must do this.  However, generally this is discouraged:
 |      among other problems, it complicates the appearance of the code.
 |      Also, when using `itemset` (and `item`) inside a loop, be sure
 |      to assign the methods to a local variable to avoid the attribute
 |      look-up at each loop iteration.
 |      
 |      Examples
 |      --------
 |      >>> x = np.random.randint(9, size=(3, 3))
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 8, 3],
 |             [8, 5, 3]])
 |      >>> x.itemset(4, 0)
 |      >>> x.itemset((2, 2), 9)
 |      >>> x
 |      array([[3, 1, 7],
 |             [2, 0, 3],
 |             [8, 5, 9]])
 |  
 |  max(...)
 |      a.max(axis=None, out=None)
 |      
 |      Return the maximum along a given axis.
 |      
 |      Refer to `numpy.amax` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amax : equivalent function
 |  
 |  mean(...)
 |      a.mean(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Returns the average of the array elements along given axis.
 |      
 |      Refer to `numpy.mean` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.mean : equivalent function
 |  
 |  min(...)
 |      a.min(axis=None, out=None, keepdims=False)
 |      
 |      Return the minimum along a given axis.
 |      
 |      Refer to `numpy.amin` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.amin : equivalent function
 |  
 |  newbyteorder(...)
 |      arr.newbyteorder(new_order='S')
 |      
 |      Return the array with the same data viewed with a different byte order.
 |      
 |      Equivalent to::
 |      
 |          arr.view(arr.dtype.newbytorder(new_order))
 |      
 |      Changes are also made in all fields and sub-arrays of the array data
 |      type.
 |      
 |      
 |      
 |      Parameters
 |      ----------
 |      new_order : string, optional
 |          Byte order to force; a value from the byte order specifications
 |          below. `new_order` codes can be any of:
 |      
 |          * 'S' - swap dtype from current to opposite endian
 |          * {'<', 'L'} - little endian
 |          * {'>', 'B'} - big endian
 |          * {'=', 'N'} - native order
 |          * {'|', 'I'} - ignore (no change to byte order)
 |      
 |          The default value ('S') results in swapping the current
 |          byte order. The code does a case-insensitive check on the first
 |          letter of `new_order` for the alternatives above.  For example,
 |          any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
 |      
 |      
 |      Returns
 |      -------
 |      new_arr : array
 |          New array object with the dtype reflecting given change to the
 |          byte order.
 |  
 |  nonzero(...)
 |      a.nonzero()
 |      
 |      Return the indices of the elements that are non-zero.
 |      
 |      Refer to `numpy.nonzero` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.nonzero : equivalent function
 |  
 |  partition(...)
 |      a.partition(kth, axis=-1, kind='introselect', order=None)
 |      
 |      Rearranges the elements in the array in such a way that value of the
 |      element in kth position is in the position it would be in a sorted array.
 |      All elements smaller than the kth element are moved before this element and
 |      all equal or greater are moved behind it. The ordering of the elements in
 |      the two partitions is undefined.
 |      
 |      .. versionadded:: 1.8.0
 |      
 |      Parameters
 |      ----------
 |      kth : int or sequence of ints
 |          Element index to partition by. The kth element value will be in its
 |          final sorted position and all smaller elements will be moved before it
 |          and all equal or greater elements behind it.
 |          The order all elements in the partitions is undefined.
 |          If provided with a sequence of kth it will partition all elements
 |          indexed by kth of them into their sorted position at once.
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'introselect'}, optional
 |          Selection algorithm. Default is 'introselect'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.partition : Return a parititioned copy of an array.
 |      argpartition : Indirect partition.
 |      sort : Full sort.
 |      
 |      Notes
 |      -----
 |      See ``np.partition`` for notes on the different algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([3, 4, 2, 1])
 |      >>> a.partition(a, 3)
 |      >>> a
 |      array([2, 1, 3, 4])
 |      
 |      >>> a.partition((1, 3))
 |      array([1, 2, 3, 4])
 |  
 |  prod(...)
 |      a.prod(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the product of the array elements over the given axis
 |      
 |      Refer to `numpy.prod` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.prod : equivalent function
 |  
 |  ptp(...)
 |      a.ptp(axis=None, out=None)
 |      
 |      Peak to peak (maximum - minimum) value along a given axis.
 |      
 |      Refer to `numpy.ptp` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ptp : equivalent function
 |  
 |  put(...)
 |      a.put(indices, values, mode='raise')
 |      
 |      Set ``a.flat[n] = values[n]`` for all `n` in indices.
 |      
 |      Refer to `numpy.put` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.put : equivalent function
 |  
 |  ravel(...)
 |      a.ravel([order])
 |      
 |      Return a flattened array.
 |      
 |      Refer to `numpy.ravel` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.ravel : equivalent function
 |      
 |      ndarray.flat : a flat iterator on the array.
 |  
 |  repeat(...)
 |      a.repeat(repeats, axis=None)
 |      
 |      Repeat elements of an array.
 |      
 |      Refer to `numpy.repeat` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.repeat : equivalent function
 |  
 |  reshape(...)
 |      a.reshape(shape, order='C')
 |      
 |      Returns an array containing the same data with a new shape.
 |      
 |      Refer to `numpy.reshape` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.reshape : equivalent function
 |  
 |  resize(...)
 |      a.resize(new_shape, refcheck=True)
 |      
 |      Change shape and size of array in-place.
 |      
 |      Parameters
 |      ----------
 |      new_shape : tuple of ints, or `n` ints
 |          Shape of resized array.
 |      refcheck : bool, optional
 |          If False, reference count will not be checked. Default is True.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      Raises
 |      ------
 |      ValueError
 |          If `a` does not own its own data or references or views to it exist,
 |          and the data memory must be changed.
 |      
 |      SystemError
 |          If the `order` keyword argument is specified. This behaviour is a
 |          bug in NumPy.
 |      
 |      See Also
 |      --------
 |      resize : Return a new array with the specified shape.
 |      
 |      Notes
 |      -----
 |      This reallocates space for the data area if necessary.
 |      
 |      Only contiguous arrays (data elements consecutive in memory) can be
 |      resized.
 |      
 |      The purpose of the reference count check is to make sure you
 |      do not use this array as a buffer for another Python object and then
 |      reallocate the memory. However, reference counts can increase in
 |      other ways so if you are sure that you have not shared the memory
 |      for this array with another Python object, then you may safely set
 |      `refcheck` to False.
 |      
 |      Examples
 |      --------
 |      Shrinking an array: array is flattened (in the order that the data are
 |      stored in memory), resized, and reshaped:
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='C')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [1]])
 |      
 |      >>> a = np.array([[0, 1], [2, 3]], order='F')
 |      >>> a.resize((2, 1))
 |      >>> a
 |      array([[0],
 |             [2]])
 |      
 |      Enlarging an array: as above, but missing entries are filled with zeros:
 |      
 |      >>> b = np.array([[0, 1], [2, 3]])
 |      >>> b.resize(2, 3) # new_shape parameter doesn't have to be a tuple
 |      >>> b
 |      array([[0, 1, 2],
 |             [3, 0, 0]])
 |      
 |      Referencing an array prevents resizing...
 |      
 |      >>> c = a
 |      >>> a.resize((1, 1))
 |      Traceback (most recent call last):
 |      ...
 |      ValueError: cannot resize an array that has been referenced ...
 |      
 |      Unless `refcheck` is False:
 |      
 |      >>> a.resize((1, 1), refcheck=False)
 |      >>> a
 |      array([[0]])
 |      >>> c
 |      array([[0]])
 |  
 |  round(...)
 |      a.round(decimals=0, out=None)
 |      
 |      Return `a` with each element rounded to the given number of decimals.
 |      
 |      Refer to `numpy.around` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.around : equivalent function
 |  
 |  searchsorted(...)
 |      a.searchsorted(v, side='left', sorter=None)
 |      
 |      Find indices where elements of v should be inserted in a to maintain order.
 |      
 |      For full documentation, see `numpy.searchsorted`
 |      
 |      See Also
 |      --------
 |      numpy.searchsorted : equivalent function
 |  
 |  setfield(...)
 |      a.setfield(val, dtype, offset=0)
 |      
 |      Put a value into a specified place in a field defined by a data-type.
 |      
 |      Place `val` into `a`'s field defined by `dtype` and beginning `offset`
 |      bytes into the field.
 |      
 |      Parameters
 |      ----------
 |      val : object
 |          Value to be placed in field.
 |      dtype : dtype object
 |          Data-type of the field in which to place `val`.
 |      offset : int, optional
 |          The number of bytes into the field at which to place `val`.
 |      
 |      Returns
 |      -------
 |      None
 |      
 |      See Also
 |      --------
 |      getfield
 |      
 |      Examples
 |      --------
 |      >>> x = np.eye(3)
 |      >>> x.getfield(np.float64)
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |      >>> x.setfield(3, np.int32)
 |      >>> x.getfield(np.int32)
 |      array([[3, 3, 3],
 |             [3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x
 |      array([[  1.00000000e+000,   1.48219694e-323,   1.48219694e-323],
 |             [  1.48219694e-323,   1.00000000e+000,   1.48219694e-323],
 |             [  1.48219694e-323,   1.48219694e-323,   1.00000000e+000]])
 |      >>> x.setfield(np.eye(3), np.int32)
 |      >>> x
 |      array([[ 1.,  0.,  0.],
 |             [ 0.,  1.,  0.],
 |             [ 0.,  0.,  1.]])
 |  
 |  setflags(...)
 |      a.setflags(write=None, align=None, uic=None)
 |      
 |      Set array flags WRITEABLE, ALIGNED, and UPDATEIFCOPY, respectively.
 |      
 |      These Boolean-valued flags affect how numpy interprets the memory
 |      area used by `a` (see Notes below). The ALIGNED flag can only
 |      be set to True if the data is actually aligned according to the type.
 |      The UPDATEIFCOPY flag can never be set to True. The flag WRITEABLE
 |      can only be set to True if the array owns its own memory, or the
 |      ultimate owner of the memory exposes a writeable buffer interface,
 |      or is a string. (The exception for string is made so that unpickling
 |      can be done without copying memory.)
 |      
 |      Parameters
 |      ----------
 |      write : bool, optional
 |          Describes whether or not `a` can be written to.
 |      align : bool, optional
 |          Describes whether or not `a` is aligned properly for its type.
 |      uic : bool, optional
 |          Describes whether or not `a` is a copy of another "base" array.
 |      
 |      Notes
 |      -----
 |      Array flags provide information about how the memory area used
 |      for the array is to be interpreted. There are 6 Boolean flags
 |      in use, only three of which can be changed by the user:
 |      UPDATEIFCOPY, WRITEABLE, and ALIGNED.
 |      
 |      WRITEABLE (W) the data area can be written to;
 |      
 |      ALIGNED (A) the data and strides are aligned appropriately for the hardware
 |      (as determined by the compiler);
 |      
 |      UPDATEIFCOPY (U) this array is a copy of some other array (referenced
 |      by .base). When this array is deallocated, the base array will be
 |      updated with the contents of this array.
 |      
 |      All flags can be accessed using their first (upper case) letter as well
 |      as the full name.
 |      
 |      Examples
 |      --------
 |      >>> y
 |      array([[3, 1, 7],
 |             [2, 0, 0],
 |             [8, 5, 9]])
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : True
 |        ALIGNED : True
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(write=0, align=0)
 |      >>> y.flags
 |        C_CONTIGUOUS : True
 |        F_CONTIGUOUS : False
 |        OWNDATA : True
 |        WRITEABLE : False
 |        ALIGNED : False
 |        UPDATEIFCOPY : False
 |      >>> y.setflags(uic=1)
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: cannot set UPDATEIFCOPY flag to True
 |  
 |  sort(...)
 |      a.sort(axis=-1, kind='quicksort', order=None)
 |      
 |      Sort an array, in-place.
 |      
 |      Parameters
 |      ----------
 |      axis : int, optional
 |          Axis along which to sort. Default is -1, which means sort along the
 |          last axis.
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          Sorting algorithm. Default is 'quicksort'.
 |      order : str or list of str, optional
 |          When `a` is an array with fields defined, this argument specifies
 |          which fields to compare first, second, etc.  A single field can
 |          be specified as a string, and not all fields need be specified,
 |          but unspecified fields will still be used, in the order in which
 |          they come up in the dtype, to break ties.
 |      
 |      See Also
 |      --------
 |      numpy.sort : Return a sorted copy of an array.
 |      argsort : Indirect sort.
 |      lexsort : Indirect stable sort on multiple keys.
 |      searchsorted : Find elements in sorted array.
 |      partition: Partial sort.
 |      
 |      Notes
 |      -----
 |      See ``sort`` for notes on the different sorting algorithms.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1,4], [3,1]])
 |      >>> a.sort(axis=1)
 |      >>> a
 |      array([[1, 4],
 |             [1, 3]])
 |      >>> a.sort(axis=0)
 |      >>> a
 |      array([[1, 3],
 |             [1, 4]])
 |      
 |      Use the `order` keyword to specify a field to use when sorting a
 |      structured array:
 |      
 |      >>> a = np.array([('a', 2), ('c', 1)], dtype=[('x', 'S1'), ('y', int)])
 |      >>> a.sort(order='y')
 |      >>> a
 |      array([('c', 1), ('a', 2)],
 |            dtype=[('x', '|S1'), ('y', '<i4')])
 |  
 |  squeeze(...)
 |      a.squeeze(axis=None)
 |      
 |      Remove single-dimensional entries from the shape of `a`.
 |      
 |      Refer to `numpy.squeeze` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.squeeze : equivalent function
 |  
 |  std(...)
 |      a.std(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the standard deviation of the array elements along given axis.
 |      
 |      Refer to `numpy.std` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.std : equivalent function
 |  
 |  sum(...)
 |      a.sum(axis=None, dtype=None, out=None, keepdims=False)
 |      
 |      Return the sum of the array elements over the given axis.
 |      
 |      Refer to `numpy.sum` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.sum : equivalent function
 |  
 |  swapaxes(...)
 |      a.swapaxes(axis1, axis2)
 |      
 |      Return a view of the array with `axis1` and `axis2` interchanged.
 |      
 |      Refer to `numpy.swapaxes` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.swapaxes : equivalent function
 |  
 |  take(...)
 |      a.take(indices, axis=None, out=None, mode='raise')
 |      
 |      Return an array formed from the elements of `a` at the given indices.
 |      
 |      Refer to `numpy.take` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.take : equivalent function
 |  
 |  tobytes(...)
 |      a.tobytes(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      .. versionadded:: 1.9.0
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  tofile(...)
 |      a.tofile(fid, sep="", format="%s")
 |      
 |      Write array to a file as text or binary (default).
 |      
 |      Data is always written in 'C' order, independent of the order of `a`.
 |      The data produced by this method can be recovered using the function
 |      fromfile().
 |      
 |      Parameters
 |      ----------
 |      fid : file or str
 |          An open file object, or a string containing a filename.
 |      sep : str
 |          Separator between array items for text output.
 |          If "" (empty), a binary file is written, equivalent to
 |          ``file.write(a.tobytes())``.
 |      format : str
 |          Format string for text file output.
 |          Each entry in the array is formatted to text by first converting
 |          it to the closest Python type, and then using "format" % item.
 |      
 |      Notes
 |      -----
 |      This is a convenience function for quick storage of array data.
 |      Information on endianness and precision is lost, so this method is not a
 |      good choice for files intended to archive data or transport data between
 |      machines with different endianness. Some of these problems can be overcome
 |      by outputting the data as text files, at the expense of speed and file
 |      size.
 |  
 |  tolist(...)
 |      a.tolist()
 |      
 |      Return the array as a (possibly nested) list.
 |      
 |      Return a copy of the array data as a (nested) Python list.
 |      Data items are converted to the nearest compatible Python type.
 |      
 |      Parameters
 |      ----------
 |      none
 |      
 |      Returns
 |      -------
 |      y : list
 |          The possibly nested list of array elements.
 |      
 |      Notes
 |      -----
 |      The array may be recreated, ``a = np.array(a.tolist())``.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([1, 2])
 |      >>> a.tolist()
 |      [1, 2]
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> list(a)
 |      [array([1, 2]), array([3, 4])]
 |      >>> a.tolist()
 |      [[1, 2], [3, 4]]
 |  
 |  tostring(...)
 |      a.tostring(order='C')
 |      
 |      Construct Python bytes containing the raw data bytes in the array.
 |      
 |      Constructs Python bytes showing a copy of the raw contents of
 |      data memory. The bytes object can be produced in either 'C' or 'Fortran',
 |      or 'Any' order (the default is 'C'-order). 'Any' order means C-order
 |      unless the F_CONTIGUOUS flag in the array is set, in which case it
 |      means 'Fortran' order.
 |      
 |      This function is a compatibility alias for tobytes. Despite its name it returns bytes not strings.
 |      
 |      Parameters
 |      ----------
 |      order : {'C', 'F', None}, optional
 |          Order of the data for multidimensional arrays:
 |          C, Fortran, or the same as for the original array.
 |      
 |      Returns
 |      -------
 |      s : bytes
 |          Python bytes exhibiting a copy of `a`'s raw data.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[0, 1], [2, 3]])
 |      >>> x.tobytes()
 |      b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
 |      >>> x.tobytes('C') == x.tobytes()
 |      True
 |      >>> x.tobytes('F')
 |      b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
 |  
 |  trace(...)
 |      a.trace(offset=0, axis1=0, axis2=1, dtype=None, out=None)
 |      
 |      Return the sum along diagonals of the array.
 |      
 |      Refer to `numpy.trace` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.trace : equivalent function
 |  
 |  transpose(...)
 |      a.transpose(*axes)
 |      
 |      Returns a view of the array with axes transposed.
 |      
 |      For a 1-D array, this has no effect. (To change between column and
 |      row vectors, first cast the 1-D array into a matrix object.)
 |      For a 2-D array, this is the usual matrix transpose.
 |      For an n-D array, if axes are given, their order indicates how the
 |      axes are permuted (see Examples). If axes are not provided and
 |      ``a.shape = (i[0], i[1], ... i[n-2], i[n-1])``, then
 |      ``a.transpose().shape = (i[n-1], i[n-2], ... i[1], i[0])``.
 |      
 |      Parameters
 |      ----------
 |      axes : None, tuple of ints, or `n` ints
 |      
 |       * None or no argument: reverses the order of the axes.
 |      
 |       * tuple of ints: `i` in the `j`-th place in the tuple means `a`'s
 |         `i`-th axis becomes `a.transpose()`'s `j`-th axis.
 |      
 |       * `n` ints: same as an n-tuple of the same ints (this form is
 |         intended simply as a "convenience" alternative to the tuple form)
 |      
 |      Returns
 |      -------
 |      out : ndarray
 |          View of `a`, with axes suitably permuted.
 |      
 |      See Also
 |      --------
 |      ndarray.T : Array property returning the array transposed.
 |      
 |      Examples
 |      --------
 |      >>> a = np.array([[1, 2], [3, 4]])
 |      >>> a
 |      array([[1, 2],
 |             [3, 4]])
 |      >>> a.transpose()
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose((1, 0))
 |      array([[1, 3],
 |             [2, 4]])
 |      >>> a.transpose(1, 0)
 |      array([[1, 3],
 |             [2, 4]])
 |  
 |  var(...)
 |      a.var(axis=None, dtype=None, out=None, ddof=0, keepdims=False)
 |      
 |      Returns the variance of the array elements, along given axis.
 |      
 |      Refer to `numpy.var` for full documentation.
 |      
 |      See Also
 |      --------
 |      numpy.var : equivalent function
 |  
 |  view(...)
 |      a.view(dtype=None, type=None)
 |      
 |      New view of array with the same data.
 |      
 |      Parameters
 |      ----------
 |      dtype : data-type or ndarray sub-class, optional
 |          Data-type descriptor of the returned view, e.g., float32 or int16. The
 |          default, None, results in the view having the same data-type as `a`.
 |          This argument can also be specified as an ndarray sub-class, which
 |          then specifies the type of the returned object (this is equivalent to
 |          setting the ``type`` parameter).
 |      type : Python type, optional
 |          Type of the returned view, e.g., ndarray or matrix.  Again, the
 |          default None results in type preservation.
 |      
 |      Notes
 |      -----
 |      ``a.view()`` is used two different ways:
 |      
 |      ``a.view(some_dtype)`` or ``a.view(dtype=some_dtype)`` constructs a view
 |      of the array's memory with a different data-type.  This can cause a
 |      reinterpretation of the bytes of memory.
 |      
 |      ``a.view(ndarray_subclass)`` or ``a.view(type=ndarray_subclass)`` just
 |      returns an instance of `ndarray_subclass` that looks at the same array
 |      (same shape, dtype, etc.)  This does not cause a reinterpretation of the
 |      memory.
 |      
 |      For ``a.view(some_dtype)``, if ``some_dtype`` has a different number of
 |      bytes per entry than the previous dtype (for example, converting a
 |      regular array to a structured array), then the behavior of the view
 |      cannot be predicted just from the superficial appearance of ``a`` (shown
 |      by ``print(a)``). It also depends on exactly how ``a`` is stored in
 |      memory. Therefore if ``a`` is C-ordered versus fortran-ordered, versus
 |      defined as a slice or transpose, etc., the view may give different
 |      results.
 |      
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([(1, 2)], dtype=[('a', np.int8), ('b', np.int8)])
 |      
 |      Viewing array data using a different type and dtype:
 |      
 |      >>> y = x.view(dtype=np.int16, type=np.matrix)
 |      >>> y
 |      matrix([[513]], dtype=int16)
 |      >>> print(type(y))
 |      <class 'numpy.matrixlib.defmatrix.matrix'>
 |      
 |      Creating a view on a structured array so it can be used in calculations
 |      
 |      >>> x = np.array([(1, 2),(3,4)], dtype=[('a', np.int8), ('b', np.int8)])
 |      >>> xv = x.view(dtype=np.int8).reshape(-1,2)
 |      >>> xv
 |      array([[1, 2],
 |             [3, 4]], dtype=int8)
 |      >>> xv.mean(0)
 |      array([ 2.,  3.])
 |      
 |      Making changes to the view changes the underlying array
 |      
 |      >>> xv[0,1] = 20
 |      >>> print(x)
 |      [(1, 20) (3, 4)]
 |      
 |      Using a view to convert an array to a recarray:
 |      
 |      >>> z = x.view(np.recarray)
 |      >>> z.a
 |      array([1], dtype=int8)
 |      
 |      Views share data:
 |      
 |      >>> x[0] = (9, 10)
 |      >>> z[0]
 |      (9, 10)
 |      
 |      Views that change the dtype size (bytes per entry) should normally be
 |      avoided on arrays defined by slices, transposes, fortran-ordering, etc.:
 |      
 |      >>> x = np.array([[1,2,3],[4,5,6]], dtype=np.int16)
 |      >>> y = x[:, 0:2]
 |      >>> y
 |      array([[1, 2],
 |             [4, 5]], dtype=int16)
 |      >>> y.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: new type not compatible with array.
 |      >>> z = y.copy()
 |      >>> z.view(dtype=[('width', np.int16), ('length', np.int16)])
 |      array([[(1, 2)],
 |             [(4, 5)]], dtype=[('width', '<i2'), ('length', '<i2')])
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Same as self.transpose(), except that self is returned if
 |      self.ndim < 2.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([[1.,2.],[3.,4.]])
 |      >>> x
 |      array([[ 1.,  2.],
 |             [ 3.,  4.]])
 |      >>> x.T
 |      array([[ 1.,  3.],
 |             [ 2.,  4.]])
 |      >>> x = np.array([1.,2.,3.,4.])
 |      >>> x
 |      array([ 1.,  2.,  3.,  4.])
 |      >>> x.T
 |      array([ 1.,  2.,  3.,  4.])
 |  
 |  __array_finalize__
 |      None.
 |  
 |  __array_interface__
 |      Array protocol: Python side.
 |  
 |  __array_priority__
 |      Array priority.
 |  
 |  __array_struct__
 |      Array protocol: C-struct side.
 |  
 |  base
 |      Base object if memory is from some other object.
 |      
 |      Examples
 |      --------
 |      The base of an array that owns its memory is None:
 |      
 |      >>> x = np.array([1,2,3,4])
 |      >>> x.base is None
 |      True
 |      
 |      Slicing creates a view, whose memory is shared with x:
 |      
 |      >>> y = x[2:]
 |      >>> y.base is x
 |      True
 |  
 |  ctypes
 |      An object to simplify the interaction of the array with the ctypes
 |      module.
 |      
 |      This attribute creates an object that makes it easier to use arrays
 |      when calling shared libraries with the ctypes module. The returned
 |      object has, among others, data, shape, and strides attributes (see
 |      Notes below) which themselves return ctypes objects that can be used
 |      as arguments to a shared library.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      c : Python object
 |          Possessing attributes data, shape, strides, etc.
 |      
 |      See Also
 |      --------
 |      numpy.ctypeslib
 |      
 |      Notes
 |      -----
 |      Below are the public attributes of this object which were documented
 |      in "Guide to NumPy" (we have omitted undocumented public attributes,
 |      as well as documented private attributes):
 |      
 |      * data: A pointer to the memory area of the array as a Python integer.
 |        This memory area may contain data that is not aligned, or not in correct
 |        byte-order. The memory area may not even be writeable. The array
 |        flags and data-type of this array should be respected when passing this
 |        attribute to arbitrary C-code to avoid trouble that can include Python
 |        crashing. User Beware! The value of this attribute is exactly the same
 |        as self._array_interface_['data'][0].
 |      
 |      * shape (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the C-integer corresponding to dtype('p') on this
 |        platform. This base-type could be c_int, c_long, or c_longlong
 |        depending on the platform. The c_intp type is defined accordingly in
 |        numpy.ctypeslib. The ctypes array contains the shape of the underlying
 |        array.
 |      
 |      * strides (c_intp*self.ndim): A ctypes array of length self.ndim where
 |        the basetype is the same as for the shape attribute. This ctypes array
 |        contains the strides information from the underlying array. This strides
 |        information is important for showing how many bytes must be jumped to
 |        get to the next element in the array.
 |      
 |      * data_as(obj): Return the data pointer cast to a particular c-types object.
 |        For example, calling self._as_parameter_ is equivalent to
 |        self.data_as(ctypes.c_void_p). Perhaps you want to use the data as a
 |        pointer to a ctypes array of floating-point data:
 |        self.data_as(ctypes.POINTER(ctypes.c_double)).
 |      
 |      * shape_as(obj): Return the shape tuple as an array of some other c-types
 |        type. For example: self.shape_as(ctypes.c_short).
 |      
 |      * strides_as(obj): Return the strides tuple as an array of some other
 |        c-types type. For example: self.strides_as(ctypes.c_longlong).
 |      
 |      Be careful using the ctypes attribute - especially on temporary
 |      arrays or arrays constructed on the fly. For example, calling
 |      ``(a+b).ctypes.data_as(ctypes.c_void_p)`` returns a pointer to memory
 |      that is invalid because the array created as (a+b) is deallocated
 |      before the next Python statement. You can avoid this problem using
 |      either ``c=a+b`` or ``ct=(a+b).ctypes``. In the latter case, ct will
 |      hold a reference to the array until ct is deleted or re-assigned.
 |      
 |      If the ctypes module is not available, then the ctypes attribute
 |      of array objects still returns something useful, but ctypes objects
 |      are not returned and errors may be raised instead. In particular,
 |      the object will still have the as parameter attribute which will
 |      return an integer equal to the data attribute.
 |      
 |      Examples
 |      --------
 |      >>> import ctypes
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.ctypes.data
 |      30439712
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long))
 |      <ctypes.LP_c_long object at 0x01F01300>
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_long)).contents
 |      c_long(0)
 |      >>> x.ctypes.data_as(ctypes.POINTER(ctypes.c_longlong)).contents
 |      c_longlong(4294967296L)
 |      >>> x.ctypes.shape
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FFD580>
 |      >>> x.ctypes.shape_as(ctypes.c_long)
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides
 |      <numpy.core._internal.c_long_Array_2 object at 0x01FCE620>
 |      >>> x.ctypes.strides_as(ctypes.c_longlong)
 |      <numpy.core._internal.c_longlong_Array_2 object at 0x01F01300>
 |  
 |  data
 |      Python buffer object pointing to the start of the array's data.
 |  
 |  dtype
 |      Data-type of the array's elements.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      d : numpy dtype object
 |      
 |      See Also
 |      --------
 |      numpy.dtype
 |      
 |      Examples
 |      --------
 |      >>> x
 |      array([[0, 1],
 |             [2, 3]])
 |      >>> x.dtype
 |      dtype('int32')
 |      >>> type(x.dtype)
 |      <type 'numpy.dtype'>
 |  
 |  flags
 |      Information about the memory layout of the array.
 |      
 |      Attributes
 |      ----------
 |      C_CONTIGUOUS (C)
 |          The data is in a single, C-style contiguous segment.
 |      F_CONTIGUOUS (F)
 |          The data is in a single, Fortran-style contiguous segment.
 |      OWNDATA (O)
 |          The array owns the memory it uses or borrows it from another object.
 |      WRITEABLE (W)
 |          The data area can be written to.  Setting this to False locks
 |          the data, making it read-only.  A view (slice, etc.) inherits WRITEABLE
 |          from its base array at creation time, but a view of a writeable
 |          array may be subsequently locked while the base array remains writeable.
 |          (The opposite is not true, in that a view of a locked array may not
 |          be made writeable.  However, currently, locking a base object does not
 |          lock any views that already reference it, so under that circumstance it
 |          is possible to alter the contents of a locked array via a previously
 |          created writeable view onto it.)  Attempting to change a non-writeable
 |          array raises a RuntimeError exception.
 |      ALIGNED (A)
 |          The data and all elements are aligned appropriately for the hardware.
 |      UPDATEIFCOPY (U)
 |          This array is a copy of some other array. When this array is
 |          deallocated, the base array will be updated with the contents of
 |          this array.
 |      FNC
 |          F_CONTIGUOUS and not C_CONTIGUOUS.
 |      FORC
 |          F_CONTIGUOUS or C_CONTIGUOUS (one-segment test).
 |      BEHAVED (B)
 |          ALIGNED and WRITEABLE.
 |      CARRAY (CA)
 |          BEHAVED and C_CONTIGUOUS.
 |      FARRAY (FA)
 |          BEHAVED and F_CONTIGUOUS and not C_CONTIGUOUS.
 |      
 |      Notes
 |      -----
 |      The `flags` object can be accessed dictionary-like (as in ``a.flags['WRITEABLE']``),
 |      or by using lowercased attribute names (as in ``a.flags.writeable``). Short flag
 |      names are only supported in dictionary access.
 |      
 |      Only the UPDATEIFCOPY, WRITEABLE, and ALIGNED flags can be changed by
 |      the user, via direct assignment to the attribute or dictionary entry,
 |      or by calling `ndarray.setflags`.
 |      
 |      The array flags cannot be set arbitrarily:
 |      
 |      - UPDATEIFCOPY can only be set ``False``.
 |      - ALIGNED can only be set ``True`` if the data is truly aligned.
 |      - WRITEABLE can only be set ``True`` if the array owns its own memory
 |        or the ultimate owner of the memory exposes a writeable buffer
 |        interface or is a string.
 |      
 |      Arrays can be both C-style and Fortran-style contiguous simultaneously.
 |      This is clear for 1-dimensional arrays, but can also be true for higher
 |      dimensional arrays.
 |      
 |      Even for contiguous arrays a stride for a given dimension
 |      ``arr.strides[dim]`` may be *arbitrary* if ``arr.shape[dim] == 1``
 |      or the array has no elements.
 |      It does *not* generally hold that ``self.strides[-1] == self.itemsize``
 |      for C-style contiguous arrays or ``self.strides[0] == self.itemsize`` for
 |      Fortran-style contiguous arrays is true.
 |  
 |  flat
 |      A 1-D iterator over the array.
 |      
 |      This is a `numpy.flatiter` instance, which acts similarly to, but is not
 |      a subclass of, Python's built-in iterator object.
 |      
 |      See Also
 |      --------
 |      flatten : Return a copy of the array collapsed into one dimension.
 |      
 |      flatiter
 |      
 |      Examples
 |      --------
 |      >>> x = np.arange(1, 7).reshape(2, 3)
 |      >>> x
 |      array([[1, 2, 3],
 |             [4, 5, 6]])
 |      >>> x.flat[3]
 |      4
 |      >>> x.T
 |      array([[1, 4],
 |             [2, 5],
 |             [3, 6]])
 |      >>> x.T.flat[3]
 |      5
 |      >>> type(x.flat)
 |      <type 'numpy.flatiter'>
 |      
 |      An assignment example:
 |      
 |      >>> x.flat = 3; x
 |      array([[3, 3, 3],
 |             [3, 3, 3]])
 |      >>> x.flat[[1,4]] = 1; x
 |      array([[3, 1, 3],
 |             [3, 1, 3]])
 |  
 |  imag
 |      The imaginary part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.imag
 |      array([ 0.        ,  0.70710678])
 |      >>> x.imag.dtype
 |      dtype('float64')
 |  
 |  itemsize
 |      Length of one array element in bytes.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1,2,3], dtype=np.float64)
 |      >>> x.itemsize
 |      8
 |      >>> x = np.array([1,2,3], dtype=np.complex128)
 |      >>> x.itemsize
 |      16
 |  
 |  nbytes
 |      Total bytes consumed by the elements of the array.
 |      
 |      Notes
 |      -----
 |      Does not include memory consumed by non-element attributes of the
 |      array object.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3,5,2), dtype=np.complex128)
 |      >>> x.nbytes
 |      480
 |      >>> np.prod(x.shape) * x.itemsize
 |      480
 |  
 |  ndim
 |      Number of array dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3])
 |      >>> x.ndim
 |      1
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.ndim
 |      3
 |  
 |  real
 |      The real part of the array.
 |      
 |      Examples
 |      --------
 |      >>> x = np.sqrt([1+0j, 0+1j])
 |      >>> x.real
 |      array([ 1.        ,  0.70710678])
 |      >>> x.real.dtype
 |      dtype('float64')
 |      
 |      See Also
 |      --------
 |      numpy.real : equivalent function
 |  
 |  shape
 |      Tuple of array dimensions.
 |      
 |      Notes
 |      -----
 |      May be used to "reshape" the array, as long as this would not
 |      require a change in the total number of elements
 |      
 |      Examples
 |      --------
 |      >>> x = np.array([1, 2, 3, 4])
 |      >>> x.shape
 |      (4,)
 |      >>> y = np.zeros((2, 3, 4))
 |      >>> y.shape
 |      (2, 3, 4)
 |      >>> y.shape = (3, 8)
 |      >>> y
 |      array([[ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.],
 |             [ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.]])
 |      >>> y.shape = (3, 6)
 |      Traceback (most recent call last):
 |        File "<stdin>", line 1, in <module>
 |      ValueError: total size of new array must be unchanged
 |  
 |  size
 |      Number of elements in the array.
 |      
 |      Equivalent to ``np.prod(a.shape)``, i.e., the product of the array's
 |      dimensions.
 |      
 |      Examples
 |      --------
 |      >>> x = np.zeros((3, 5, 2), dtype=np.complex128)
 |      >>> x.size
 |      30
 |      >>> np.prod(x.shape)
 |      30
 |  
 |  strides
 |      Tuple of bytes to step in each dimension when traversing an array.
 |      
 |      The byte offset of element ``(i[0], i[1], ..., i[n])`` in an array `a`
 |      is::
 |      
 |          offset = sum(np.array(i) * a.strides)
 |      
 |      A more detailed explanation of strides can be found in the
 |      "ndarray.rst" file in the NumPy reference guide.
 |      
 |      Notes
 |      -----
 |      Imagine an array of 32-bit integers (each 4 bytes)::
 |      
 |        x = np.array([[0, 1, 2, 3, 4],
 |                      [5, 6, 7, 8, 9]], dtype=np.int32)
 |      
 |      This array is stored in memory as 40 bytes, one after the other
 |      (known as a contiguous block of memory).  The strides of an array tell
 |      us how many bytes we have to skip in memory to move to the next position
 |      along a certain axis.  For example, we have to skip 4 bytes (1 value) to
 |      move to the next column, but 20 bytes (5 values) to get to the same
 |      position in the next row.  As such, the strides for the array `x` will be
 |      ``(20, 4)``.
 |      
 |      See Also
 |      --------
 |      numpy.lib.stride_tricks.as_strided
 |      
 |      Examples
 |      --------
 |      >>> y = np.reshape(np.arange(2*3*4), (2,3,4))
 |      >>> y
 |      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]]])
 |      >>> y.strides
 |      (48, 16, 4)
 |      >>> y[1,1,1]
 |      17
 |      >>> offset=sum(y.strides * np.array((1,1,1)))
 |      >>> offset/y.itemsize
 |      17
 |      
 |      >>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
 |      >>> x.strides
 |      (32, 4, 224, 1344)
 |      >>> i = np.array([3,5,2,2])
 |      >>> offset = sum(i * x.strides)
 |      >>> x[3,5,2,2]
 |      813
 |      >>> offset / x.itemsize
 |      813
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

In [48]:

    

dir(arr)


    

    
Out[48]:





['T',
 '__abs__',
 '__add__',
 '__and__',
 '__array__',
 '__array_finalize__',
 '__array_interface__',
 '__array_prepare__',
 '__array_priority__',
 '__array_struct__',
 '__array_wrap__',
 '__bool__',
 '__class__',
 '__contains__',
 '__copy__',
 '__deepcopy__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__divmod__',
 '__doc__',
 '__eq__',
 '__float__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__iand__',
 '__ifloordiv__',
 '__ilshift__',
 '__imatmul__',
 '__imod__',
 '__imul__',
 '__index__',
 '__init__',
 '__int__',
 '__invert__',
 '__ior__',
 '__ipow__',
 '__irshift__',
 '__isub__',
 '__iter__',
 '__itruediv__',
 '__ixor__',
 '__le__',
 '__len__',
 '__lshift__',
 '__lt__',
 '__matmul__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__or__',
 '__pos__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdivmod__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rlshift__',
 '__rmatmul__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__rpow__',
 '__rrshift__',
 '__rshift__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__setattr__',
 '__setitem__',
 '__setstate__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__xor__',
 'all',
 'any',
 'argmax',
 'argmin',
 'argpartition',
 'argsort',
 'astype',
 'base',
 'byteswap',
 'choose',
 'clip',
 'compress',
 'conj',
 'conjugate',
 'copy',
 'ctypes',
 'cumprod',
 'cumsum',
 'data',
 'diagonal',
 'dot',
 'dtype',
 'dump',
 'dumps',
 'fill',
 'flags',
 'flat',
 'flatten',
 'getfield',
 'imag',
 'item',
 'itemset',
 'itemsize',
 'max',
 'mean',
 'min',
 'nbytes',
 'ndim',
 'newbyteorder',
 'nonzero',
 'partition',
 'prod',
 'ptp',
 'put',
 'ravel',
 'real',
 'repeat',
 'reshape',
 'resize',
 'round',
 'searchsorted',
 'setfield',
 'setflags',
 'shape',
 'size',
 'sort',
 'squeeze',
 'std',
 'strides',
 'sum',
 'swapaxes',
 'take',
 'tobytes',
 'tofile',
 'tolist',
 'tostring',
 'trace',
 'transpose',
 'var',
 'view']

In [37]:

    

arr.shape


    

    
Out[37]:





(4,)

In [38]:

    

arr.ndim


    

    
Out[38]:





1

In [40]:

    

data = [[1, 2], [3, 4]]
arr = np.array(data)
arr


    

    
Out[40]:





array([[1, 2],
       [3, 4]])

In [41]:

    

arr.shape


    

    
Out[41]:





(2, 2)

In [42]:

    

arr.ndim


    

    
Out[42]:





2

In [2]:

    

from pandas import Series, DataFrame
import pandas as pd


    

In [63]:

    

obj = Series([4, 7, -5, 3])
obj


    

    
Out[63]:





0    4
1    7
2   -5
3    3
dtype: int64

In [65]:

    

help(Series)


    

    




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

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 any 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 unique and hashable, same length as data. Index
 |      object (or other iterable of same length as data) 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
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__ = wrapper(left, right, name='__add__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d6a8>)
 |  
 |  __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 0x10945dae8>)
 |  
 |  __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 0x10945dbf8>)
 |  
 |  __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 0x10945dd08>)
 |  
 |  __mul__ = wrapper(left, right, name='__mul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d9d8>)
 |  
 |  __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 0x10945de18>)
 |  
 |  __radd__ = wrapper(left, right, name='__radd__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d7b8>)
 |  
 |  __rand__ = wrapper(self, other)
 |  
 |  __rdiv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rfloordiv__ = wrapper(left, right, name='__rfloordiv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463488>)
 |  
 |  __rmod__ = wrapper(left, right, name='__rmod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094637b8>)
 |  
 |  __rmul__ = wrapper(left, right, name='__rmul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945df28>)
 |  
 |  __ror__ = wrapper(self, other)
 |  
 |  __rpow__ = wrapper(left, right, name='__rpow__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463620>)
 |  
 |  __rsub__ = wrapper(left, right, name='__rsub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463158>)
 |  
 |  __rtruediv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rxor__ = wrapper(self, other)
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__ = wrapper(left, right, name='__sub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d8c8>)
 |  
 |  __truediv__ = wrapper(left, right, name='__truediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945dae8>)
 |  
 |  __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
 |  
 |  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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      any : scalar or Series (if level specified)
 |  
 |  append(self, to_append, verify_integrity=False)
 |      Concatenate two or more Series.
 |      
 |      Parameters
 |      ----------
 |      to_append : Series or list/tuple of Series
 |      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 `verify_integrity` set to True:
 |      
 |      >>> s1.append(s2, verify_integrity=True)
 |      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
 |      
 |      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'])
 |      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, out=None, skipna=True)
 |  
 |  argmin = idxmin(self, axis=None, out=None, skipna=True)
 |  
 |  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
 |  
 |  asof(self, where)
 |      Return last good (non-NaN) value in Series if value is NaN for
 |      requested date.
 |      
 |      If there is no good value, NaN is returned.
 |      
 |      Parameters
 |      ----------
 |      where : date or array of dates
 |      
 |      Notes
 |      -----
 |      Dates are assumed to be sorted
 |      
 |      Returns
 |      -------
 |      value or NaN
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      compounded : scalar or Series (if level specified)
 |  
 |  compress(self, condition, axis=0, out=None, **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 = max(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      max : scalar
 |  
 |  cummin = min(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative min 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
 |      -------
 |      min : scalar
 |  
 |  cumprod = prod(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative prod 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
 |      -------
 |      prod : scalar
 |  
 |  cumsum = sum(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      sum : scalar
 |  
 |  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.
 |      take_last : deprecated
 |      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``.
 |      take_last : deprecated
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq = wrapper(self, other, axis=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
 |      
 |      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, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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.
 |      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 = wrapper(self, other, axis=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 = wrapper(self, other, axis=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, out=None, skipna=True)
 |      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, out=None, skipna=True)
 |      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
 |  
 |  iget(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  iget_value(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  irow(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  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 : 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.
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 = wrapper(self, other, axis=None)
 |  
 |  lt = wrapper(self, other, axis=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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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
 |      
 |      Examples
 |      --------
 |      >>> x
 |      one   1
 |      two   2
 |      three 3
 |      
 |      >>> y
 |      1  foo
 |      2  bar
 |      3  baz
 |      
 |      >>> x.map(y)
 |      one   foo
 |      two   bar
 |      three baz
 |      
 |      Returns
 |      -------
 |      y : Series
 |          same index as caller
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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)
 |      Returns the mode(s) of the dataset.
 |      
 |      Empty if nothing occurs at least 2 times.  Always returns Series even
 |      if only one value.
 |      
 |      Parameters
 |      ----------
 |      sort : bool, default True
 |          If True, will lexicographically sort values, if False skips
 |          sorting. Result ordering when ``sort=False`` is not defined.
 |      
 |      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 = wrapper(self, other, axis=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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nlargest(10)  # only sorts up to the N requested
 |  
 |  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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nsmallest(10)  # only sorts up to the N requested
 |  
 |  order(self, na_last=None, ascending=True, kind='quicksort', na_position='last', inplace=False)
 |      DEPRECATED: use :meth:`Series.sort_values`
 |      
 |      Sorts Series object, by value, maintaining index-value link.
 |      This will return a new Series by default. Series.sort is the equivalent
 |      but as an inplace method.
 |      
 |      Parameters
 |      ----------
 |      na_last : boolean (optional, default=True)--DEPRECATED; use na_position
 |          Put NaN's at beginning or end
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default False
 |          Do operation in place.
 |      
 |      Returns
 |      -------
 |      y : Series
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      ptp : scalar or Series (if level specified)
 |  
 |  put(self, *args, **kwargs)
 |      return a ndarray with the values put
 |      
 |      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.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                   404           0.08
 |      Chrome                 200           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. 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.
 |      
 |      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)
 |      ...
 |      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
 |  
 |  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, reps)
 |      return a new Series with the values repeated reps times
 |      
 |      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)
 |      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.take
 |  
 |  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, axis=0)
 |      Provides rolling transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int
 |         Size of the moving window. This is the number of observations used for
 |         calculating the statistic.
 |      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.
 |      win_type : string, default None
 |          prove a window type, see the notes below
 |      axis : int, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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`).
 |      
 |      The recognized window 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)
 |      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
 |  
 |  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, v, 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 `v` were inserted before the indices, the
 |      order of `self` would be preserved.
 |      
 |      Parameters
 |      ----------
 |      v : array_like
 |          Values to insert into `a`.
 |      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 `a`).
 |      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 `v`.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |      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.searchsorted([1, 2], side='right', sorter=[0, 2, 1])
 |      array([1, 3])
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 datetools 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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      skew : scalar or Series (if level specified)
 |  
 |  sort(self, axis=0, ascending=True, kind='quicksort', na_position='last', inplace=True)
 |      DEPRECATED: use :meth:`Series.sort_values(inplace=True)` for INPLACE
 |      sorting
 |      
 |      Sort values and index labels by value. This is an inplace sort by
 |      default.  Series.order is the equivalent but returns a new Series.
 |      
 |      Parameters
 |      ----------
 |      axis : int (can only be zero)
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default True
 |          Do operation in place.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, 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
 |          if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      sort_remaining : bool
 |          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
 |      ----------
 |      by : string name or list of names which refer to the axis items
 |      axis : index to direct sorting
 |      ascending : bool or list of bool
 |           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
 |           if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `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)
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sum : scalar or Series (if level specified)
 |  
 |  swaplevel(self, i, j, 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
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=False)
 |      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, index=True, sep=',', na_rep='', float_format=None, header=False, index_label=None, mode='w', nanRep=None, encoding=None, date_format=None, decimal='.')
 |      Write Series to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO. 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_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
 |  
 |  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
 |  
 |  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
 |      one  a   1.
 |      one  b   2.
 |      two  a   3.
 |      two  b   4.
 |      
 |      >>> s.unstack(level=-1)
 |           a   b
 |      one  1.  2.
 |      two  3.  4.
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a  1.   2.
 |      b  3.   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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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:
 |  
 |  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
 |  
 |  is_time_series
 |  
 |  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-01T00:00:00.000000000-0500',
 |             '2013-01-02T00:00:00.000000000-0500',
 |             '2013-01-03T00:00:00.000000000-0500'], 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.tseries.common.CombinedDatetimelikeProperties'>
 |      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.tools.plotting.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)
 |      return the transpose, which is by definition self
 |  
 |  unique(self)
 |      Return array of unique values in the object. Significantly faster than
 |      numpy.unique. Includes NA values.
 |      
 |      Returns
 |      -------
 |      uniques : ndarray
 |  
 |  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
 |  
 |  flags
 |      return the ndarray.flags for the underlying data
 |  
 |  hasnans
 |  
 |  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
 |  
 |  __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.
 |      
 |      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)
 |      Convert all TimeSeries inside to specified frequency using DateOffset
 |      objects. Optionally provide fill method to pad/backfill missing values.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill', 'bfill', 'pad', 'ffill', 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 method
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |  
 |  astype(self, dtype, copy=True, raise_on_error=True, **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : numpy.dtype or Python type
 |      raise_on_error : raise on invalid input
 |      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 NDFrame.fillna(method='bfill')
 |  
 |  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, out=None, axis=None)
 |      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)
 |      Compute NDFrame with "consolidated" internals (data of each dtype
 |      grouped together in a single ndarray). Mainly an internal API function,
 |      but available here to the savvy user
 |      
 |      Parameters
 |      ----------
 |      inplace : boolean, default False
 |          If False return new object, otherwise modify existing object
 |      
 |      Returns
 |      -------
 |      consolidated : type of caller
 |  
 |  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 object
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, i.e. also copy data
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generate various summary statistics, excluding NaN values.
 |      
 |      Parameters
 |      ----------
 |      percentiles : array-like, optional
 |          The percentiles to include in the output. Should all
 |          be in the interval [0, 1]. By default `percentiles` is
 |          [.25, .5, .75], returning the 25th, 50th, and 75th percentiles.
 |      include, exclude : list-like, 'all', or None (default)
 |          Specify the form of the returned result. Either:
 |      
 |          - None to both (default). The result will include only
 |            numeric-typed columns or, if none are, only categorical columns.
 |          - A list of dtypes or strings to be included/excluded.
 |            To select all numeric types use numpy numpy.number. To select
 |            categorical objects use type object. See also the select_dtypes
 |            documentation. eg. df.describe(include=['O'])
 |          - If include is the string 'all', the output column-set will
 |            match the input one.
 |      
 |      Returns
 |      -------
 |      summary: NDFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      The output DataFrame index depends on the requested dtypes:
 |      
 |      For numeric dtypes, it will include: count, mean, std, min,
 |      max, and lower, 50, and upper percentiles.
 |      
 |      For object dtypes (e.g. timestamps or strings), the index
 |      will include the count, unique, most common, and frequency of the
 |      most common. Timestamps also include the first and last items.
 |      
 |      For mixed dtypes, the index will be the union of the corresponding
 |      output types. Non-applicable entries will be filled with NaN.
 |      Note that mixed-dtype outputs can only be returned from mixed-dtype
 |      inputs and appropriate use of the include/exclude arguments.
 |      
 |      If multiple values have the highest count, then the
 |      `count` and `most common` pair will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      The include, exclude arguments are ignored for Series.
 |      
 |      See Also
 |      --------
 |      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 NDFrame.fillna(method='ffill')
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Restrict the info axis to set of items or wildcard
 |      
 |      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 None
 |          The axis to filter on. By default this is the info axis. The "info
 |          axis" is the axis that is used when indexing with ``[]``. For
 |          example, ``df = DataFrame({'a': [1, 2, 3, 4]]}); df['a']``. So,
 |          the ``DataFrame`` columns are the info axis.
 |      
 |      Notes
 |      -----
 |      Arguments are mutually exclusive, but this is not checked for
 |  
 |  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)
 |      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 / list of functions, dict, Series, or tuple /
 |          list of column names.
 |          Called on each element of the object index to determine the groups.
 |          If a dict or Series is passed, the Series or dict VALUES will be
 |          used to determine the groups
 |      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', 'pchip'}
 |      
 |          * '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', and 'pchip' are all
 |            wrappers around the scipy interpolation methods of similar
 |            names. These use the actual numerical values of the index. See
 |            the scipy documentation for more on their behavior
 |            `here <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__  # noqa
 |            `and here <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__  # noqa
 |      
 |      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.
 |      limit_direction : {'forward', 'backward', 'both'}, defaults to '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
 |  
 |  iterkv(self, *args, **kwargs)
 |      iteritems alias used to get around 2to3. Deprecated
 |  
 |  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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  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 scaler 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)
 |      Convenience method for frequency conversion and resampling of regular
 |      time-series data.
 |      
 |      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
 |      
 |      
 |      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
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00     1
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00     2
 |      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
 |  
 |  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)
 |      Squeeze length 1 dimensions.
 |  
 |  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)
 |      Activate the HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          indentifier for the group in the store
 |      mode : optional, {'a', 'w', 'r', 'r+'}, default 'a'
 |      
 |        ``'r'``
 |            Read-only; no data can be modified.
 |        ``'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
 |      complevel : int, 1-9, default 0
 |          If a complib is specified compression will be applied
 |          where possible
 |      complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
 |          If complevel is > 0 apply compression to objects written
 |          in the store wherever possible
 |      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='epoch', double_precision=10, force_ascii=True, date_unit='ms', default_handler=None)
 |      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
 |      
 |      date_format : {'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso`` = ISO8601, 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.
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |  
 |  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)
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |  
 |  to_sql(self, name, con, flavor='sqlite', 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', 'mysql'}, default 'sqlite'
 |          The flavor of SQL to use. Ignored when using SQLAlchemy engine.
 |          'mysql' is deprecated and will be removed in future versions, but
 |          it will be further supported through SQLAlchemy engines.
 |      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
 |      dates.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before date
 |      after : date
 |          Truncate after date
 |      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 datetools 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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  xs(self, key, axis=0, level=None, copy=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.
 |      copy : boolean [deprecated]
 |          Whether to make a copy of the data
 |      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()
 |  
 |  empty
 |      True if NDFrame is entirely empty [no items], meaning any of the
 |      axes are of length 0.
 |      
 |      Notes
 |      -----
 |      If NDFrame contains only NaNs, it is still not considered empty. See
 |      the example below.
 |      
 |      Examples
 |      --------
 |      An example of an actual empty DataFrame. Notice the index is empty:
 |      
 |      >>> df_empty = pd.DataFrame({'A' : []})
 |      >>> df_empty
 |      Empty DataFrame
 |      Columns: [A]
 |      Index: []
 |      >>> df_empty.empty
 |      True
 |      
 |      If we only have NaNs in our DataFrame, it is not considered empty! We
 |      will need to drop the NaNs to make the DataFrame empty:
 |      
 |      >>> df = pd.DataFrame({'A' : [np.nan]})
 |      >>> df
 |          A
 |      0 NaN
 |      >>> df.empty
 |      False
 |      >>> df.dropna().empty
 |      True
 |      
 |      See also
 |      --------
 |      pandas.Series.dropna
 |      pandas.DataFrame.dropna
 |  
 |  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.
 |      
 |      ``.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.
 |      
 |      ``.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.

In [66]:

    

help(obj)


    

    




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 any 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 unique and hashable, same length as data. Index
 |      object (or other iterable of same length as data) 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
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__ = wrapper(left, right, name='__add__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d6a8>)
 |  
 |  __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 0x10945dae8>)
 |  
 |  __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 0x10945dbf8>)
 |  
 |  __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 0x10945dd08>)
 |  
 |  __mul__ = wrapper(left, right, name='__mul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d9d8>)
 |  
 |  __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 0x10945de18>)
 |  
 |  __radd__ = wrapper(left, right, name='__radd__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d7b8>)
 |  
 |  __rand__ = wrapper(self, other)
 |  
 |  __rdiv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rfloordiv__ = wrapper(left, right, name='__rfloordiv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463488>)
 |  
 |  __rmod__ = wrapper(left, right, name='__rmod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094637b8>)
 |  
 |  __rmul__ = wrapper(left, right, name='__rmul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945df28>)
 |  
 |  __ror__ = wrapper(self, other)
 |  
 |  __rpow__ = wrapper(left, right, name='__rpow__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463620>)
 |  
 |  __rsub__ = wrapper(left, right, name='__rsub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463158>)
 |  
 |  __rtruediv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rxor__ = wrapper(self, other)
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__ = wrapper(left, right, name='__sub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d8c8>)
 |  
 |  __truediv__ = wrapper(left, right, name='__truediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945dae8>)
 |  
 |  __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
 |  
 |  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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      any : scalar or Series (if level specified)
 |  
 |  append(self, to_append, verify_integrity=False)
 |      Concatenate two or more Series.
 |      
 |      Parameters
 |      ----------
 |      to_append : Series or list/tuple of Series
 |      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 `verify_integrity` set to True:
 |      
 |      >>> s1.append(s2, verify_integrity=True)
 |      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
 |      
 |      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'])
 |      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, out=None, skipna=True)
 |  
 |  argmin = idxmin(self, axis=None, out=None, skipna=True)
 |  
 |  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
 |  
 |  asof(self, where)
 |      Return last good (non-NaN) value in Series if value is NaN for
 |      requested date.
 |      
 |      If there is no good value, NaN is returned.
 |      
 |      Parameters
 |      ----------
 |      where : date or array of dates
 |      
 |      Notes
 |      -----
 |      Dates are assumed to be sorted
 |      
 |      Returns
 |      -------
 |      value or NaN
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      compounded : scalar or Series (if level specified)
 |  
 |  compress(self, condition, axis=0, out=None, **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 = max(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      max : scalar
 |  
 |  cummin = min(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative min 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
 |      -------
 |      min : scalar
 |  
 |  cumprod = prod(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative prod 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
 |      -------
 |      prod : scalar
 |  
 |  cumsum = sum(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      sum : scalar
 |  
 |  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.
 |      take_last : deprecated
 |      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``.
 |      take_last : deprecated
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq = wrapper(self, other, axis=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
 |      
 |      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, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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.
 |      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 = wrapper(self, other, axis=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 = wrapper(self, other, axis=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, out=None, skipna=True)
 |      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, out=None, skipna=True)
 |      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
 |  
 |  iget(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  iget_value(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  irow(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  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 : 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.
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 = wrapper(self, other, axis=None)
 |  
 |  lt = wrapper(self, other, axis=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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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
 |      
 |      Examples
 |      --------
 |      >>> x
 |      one   1
 |      two   2
 |      three 3
 |      
 |      >>> y
 |      1  foo
 |      2  bar
 |      3  baz
 |      
 |      >>> x.map(y)
 |      one   foo
 |      two   bar
 |      three baz
 |      
 |      Returns
 |      -------
 |      y : Series
 |          same index as caller
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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)
 |      Returns the mode(s) of the dataset.
 |      
 |      Empty if nothing occurs at least 2 times.  Always returns Series even
 |      if only one value.
 |      
 |      Parameters
 |      ----------
 |      sort : bool, default True
 |          If True, will lexicographically sort values, if False skips
 |          sorting. Result ordering when ``sort=False`` is not defined.
 |      
 |      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 = wrapper(self, other, axis=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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nlargest(10)  # only sorts up to the N requested
 |  
 |  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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nsmallest(10)  # only sorts up to the N requested
 |  
 |  order(self, na_last=None, ascending=True, kind='quicksort', na_position='last', inplace=False)
 |      DEPRECATED: use :meth:`Series.sort_values`
 |      
 |      Sorts Series object, by value, maintaining index-value link.
 |      This will return a new Series by default. Series.sort is the equivalent
 |      but as an inplace method.
 |      
 |      Parameters
 |      ----------
 |      na_last : boolean (optional, default=True)--DEPRECATED; use na_position
 |          Put NaN's at beginning or end
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default False
 |          Do operation in place.
 |      
 |      Returns
 |      -------
 |      y : Series
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      ptp : scalar or Series (if level specified)
 |  
 |  put(self, *args, **kwargs)
 |      return a ndarray with the values put
 |      
 |      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.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                   404           0.08
 |      Chrome                 200           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. 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.
 |      
 |      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)
 |      ...
 |      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
 |  
 |  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, reps)
 |      return a new Series with the values repeated reps times
 |      
 |      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)
 |      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.take
 |  
 |  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, axis=0)
 |      Provides rolling transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int
 |         Size of the moving window. This is the number of observations used for
 |         calculating the statistic.
 |      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.
 |      win_type : string, default None
 |          prove a window type, see the notes below
 |      axis : int, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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`).
 |      
 |      The recognized window 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)
 |      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
 |  
 |  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, v, 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 `v` were inserted before the indices, the
 |      order of `self` would be preserved.
 |      
 |      Parameters
 |      ----------
 |      v : array_like
 |          Values to insert into `a`.
 |      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 `a`).
 |      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 `v`.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |      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.searchsorted([1, 2], side='right', sorter=[0, 2, 1])
 |      array([1, 3])
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 datetools 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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      skew : scalar or Series (if level specified)
 |  
 |  sort(self, axis=0, ascending=True, kind='quicksort', na_position='last', inplace=True)
 |      DEPRECATED: use :meth:`Series.sort_values(inplace=True)` for INPLACE
 |      sorting
 |      
 |      Sort values and index labels by value. This is an inplace sort by
 |      default.  Series.order is the equivalent but returns a new Series.
 |      
 |      Parameters
 |      ----------
 |      axis : int (can only be zero)
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default True
 |          Do operation in place.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, 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
 |          if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      sort_remaining : bool
 |          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
 |      ----------
 |      by : string name or list of names which refer to the axis items
 |      axis : index to direct sorting
 |      ascending : bool or list of bool
 |           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
 |           if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `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)
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sum : scalar or Series (if level specified)
 |  
 |  swaplevel(self, i, j, 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
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=False)
 |      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, index=True, sep=',', na_rep='', float_format=None, header=False, index_label=None, mode='w', nanRep=None, encoding=None, date_format=None, decimal='.')
 |      Write Series to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO. 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_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
 |  
 |  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
 |  
 |  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
 |      one  a   1.
 |      one  b   2.
 |      two  a   3.
 |      two  b   4.
 |      
 |      >>> s.unstack(level=-1)
 |           a   b
 |      one  1.  2.
 |      two  3.  4.
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a  1.   2.
 |      b  3.   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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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:
 |  
 |  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
 |  
 |  is_time_series
 |  
 |  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-01T00:00:00.000000000-0500',
 |             '2013-01-02T00:00:00.000000000-0500',
 |             '2013-01-03T00:00:00.000000000-0500'], 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.tseries.common.CombinedDatetimelikeProperties'>
 |      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.tools.plotting.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)
 |      return the transpose, which is by definition self
 |  
 |  unique(self)
 |      Return array of unique values in the object. Significantly faster than
 |      numpy.unique. Includes NA values.
 |      
 |      Returns
 |      -------
 |      uniques : ndarray
 |  
 |  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
 |  
 |  flags
 |      return the ndarray.flags for the underlying data
 |  
 |  hasnans
 |  
 |  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
 |  
 |  __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.
 |      
 |      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)
 |      Convert all TimeSeries inside to specified frequency using DateOffset
 |      objects. Optionally provide fill method to pad/backfill missing values.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill', 'bfill', 'pad', 'ffill', 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 method
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |  
 |  astype(self, dtype, copy=True, raise_on_error=True, **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : numpy.dtype or Python type
 |      raise_on_error : raise on invalid input
 |      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 NDFrame.fillna(method='bfill')
 |  
 |  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, out=None, axis=None)
 |      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)
 |      Compute NDFrame with "consolidated" internals (data of each dtype
 |      grouped together in a single ndarray). Mainly an internal API function,
 |      but available here to the savvy user
 |      
 |      Parameters
 |      ----------
 |      inplace : boolean, default False
 |          If False return new object, otherwise modify existing object
 |      
 |      Returns
 |      -------
 |      consolidated : type of caller
 |  
 |  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 object
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, i.e. also copy data
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generate various summary statistics, excluding NaN values.
 |      
 |      Parameters
 |      ----------
 |      percentiles : array-like, optional
 |          The percentiles to include in the output. Should all
 |          be in the interval [0, 1]. By default `percentiles` is
 |          [.25, .5, .75], returning the 25th, 50th, and 75th percentiles.
 |      include, exclude : list-like, 'all', or None (default)
 |          Specify the form of the returned result. Either:
 |      
 |          - None to both (default). The result will include only
 |            numeric-typed columns or, if none are, only categorical columns.
 |          - A list of dtypes or strings to be included/excluded.
 |            To select all numeric types use numpy numpy.number. To select
 |            categorical objects use type object. See also the select_dtypes
 |            documentation. eg. df.describe(include=['O'])
 |          - If include is the string 'all', the output column-set will
 |            match the input one.
 |      
 |      Returns
 |      -------
 |      summary: NDFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      The output DataFrame index depends on the requested dtypes:
 |      
 |      For numeric dtypes, it will include: count, mean, std, min,
 |      max, and lower, 50, and upper percentiles.
 |      
 |      For object dtypes (e.g. timestamps or strings), the index
 |      will include the count, unique, most common, and frequency of the
 |      most common. Timestamps also include the first and last items.
 |      
 |      For mixed dtypes, the index will be the union of the corresponding
 |      output types. Non-applicable entries will be filled with NaN.
 |      Note that mixed-dtype outputs can only be returned from mixed-dtype
 |      inputs and appropriate use of the include/exclude arguments.
 |      
 |      If multiple values have the highest count, then the
 |      `count` and `most common` pair will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      The include, exclude arguments are ignored for Series.
 |      
 |      See Also
 |      --------
 |      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 NDFrame.fillna(method='ffill')
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Restrict the info axis to set of items or wildcard
 |      
 |      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 None
 |          The axis to filter on. By default this is the info axis. The "info
 |          axis" is the axis that is used when indexing with ``[]``. For
 |          example, ``df = DataFrame({'a': [1, 2, 3, 4]]}); df['a']``. So,
 |          the ``DataFrame`` columns are the info axis.
 |      
 |      Notes
 |      -----
 |      Arguments are mutually exclusive, but this is not checked for
 |  
 |  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)
 |      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 / list of functions, dict, Series, or tuple /
 |          list of column names.
 |          Called on each element of the object index to determine the groups.
 |          If a dict or Series is passed, the Series or dict VALUES will be
 |          used to determine the groups
 |      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', 'pchip'}
 |      
 |          * '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', and 'pchip' are all
 |            wrappers around the scipy interpolation methods of similar
 |            names. These use the actual numerical values of the index. See
 |            the scipy documentation for more on their behavior
 |            `here <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__  # noqa
 |            `and here <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__  # noqa
 |      
 |      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.
 |      limit_direction : {'forward', 'backward', 'both'}, defaults to '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
 |  
 |  iterkv(self, *args, **kwargs)
 |      iteritems alias used to get around 2to3. Deprecated
 |  
 |  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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  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 scaler 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)
 |      Convenience method for frequency conversion and resampling of regular
 |      time-series data.
 |      
 |      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
 |      
 |      
 |      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
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00     1
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00     2
 |      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
 |  
 |  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)
 |      Squeeze length 1 dimensions.
 |  
 |  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)
 |      Activate the HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          indentifier for the group in the store
 |      mode : optional, {'a', 'w', 'r', 'r+'}, default 'a'
 |      
 |        ``'r'``
 |            Read-only; no data can be modified.
 |        ``'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
 |      complevel : int, 1-9, default 0
 |          If a complib is specified compression will be applied
 |          where possible
 |      complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
 |          If complevel is > 0 apply compression to objects written
 |          in the store wherever possible
 |      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='epoch', double_precision=10, force_ascii=True, date_unit='ms', default_handler=None)
 |      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
 |      
 |      date_format : {'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso`` = ISO8601, 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.
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |  
 |  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)
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |  
 |  to_sql(self, name, con, flavor='sqlite', 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', 'mysql'}, default 'sqlite'
 |          The flavor of SQL to use. Ignored when using SQLAlchemy engine.
 |          'mysql' is deprecated and will be removed in future versions, but
 |          it will be further supported through SQLAlchemy engines.
 |      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
 |      dates.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before date
 |      after : date
 |          Truncate after date
 |      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 datetools 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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  xs(self, key, axis=0, level=None, copy=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.
 |      copy : boolean [deprecated]
 |          Whether to make a copy of the data
 |      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()
 |  
 |  empty
 |      True if NDFrame is entirely empty [no items], meaning any of the
 |      axes are of length 0.
 |      
 |      Notes
 |      -----
 |      If NDFrame contains only NaNs, it is still not considered empty. See
 |      the example below.
 |      
 |      Examples
 |      --------
 |      An example of an actual empty DataFrame. Notice the index is empty:
 |      
 |      >>> df_empty = pd.DataFrame({'A' : []})
 |      >>> df_empty
 |      Empty DataFrame
 |      Columns: [A]
 |      Index: []
 |      >>> df_empty.empty
 |      True
 |      
 |      If we only have NaNs in our DataFrame, it is not considered empty! We
 |      will need to drop the NaNs to make the DataFrame empty:
 |      
 |      >>> df = pd.DataFrame({'A' : [np.nan]})
 |      >>> df
 |          A
 |      0 NaN
 |      >>> df.empty
 |      False
 |      >>> df.dropna().empty
 |      True
 |      
 |      See also
 |      --------
 |      pandas.Series.dropna
 |      pandas.DataFrame.dropna
 |  
 |  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.
 |      
 |      ``.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.
 |      
 |      ``.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.

In [67]:

    

obj.isnull()


    

    
Out[67]:





0    False
1    False
2    False
3    False
dtype: bool

In [53]:

    

data = {
        'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
        'year': [2000, 2001, 2002, 2001, 2002],
       }  # 사전 객체
frame = DataFrame(data)
frame


    

    
Out[53]:






  

    

      

      
state
      
year
    
  
  

    

      
0
      
Ohio
      
2000
    
    

      
1
      
Ohio
      
2001
    
    

      
2
      
Ohio
      
2002
    
    

      
3
      
Nevada
      
2001
    
    

      
4
      
Nevada
      
2002
    
  

In [54]:

    

help(DataFrame)


    

    




Help on class DataFrame in module pandas.core.frame:

class DataFrame(pandas.core.generic.NDFrame)
 |  Two-dimensional size-mutable, potentially heterogeneous tabular data
 |  structure with labeled axes (rows and columns). Arithmetic operations
 |  align on both row and column labels. Can be thought of as a dict-like
 |  container for Series objects. The primary pandas data structure
 |  
 |  Parameters
 |  ----------
 |  data : numpy ndarray (structured or homogeneous), dict, or DataFrame
 |      Dict can contain Series, arrays, constants, or list-like objects
 |  index : Index or array-like
 |      Index to use for resulting frame. Will default to np.arange(n) if
 |      no indexing information part of input data and no index provided
 |  columns : Index or array-like
 |      Column labels to use for resulting frame. Will default to
 |      np.arange(n) if no column labels are provided
 |  dtype : dtype, default None
 |      Data type to force, otherwise infer
 |  copy : boolean, default False
 |      Copy data from inputs. Only affects DataFrame / 2d ndarray input
 |  
 |  Examples
 |  --------
 |  >>> d = {'col1': ts1, 'col2': ts2}
 |  >>> df = DataFrame(data=d, index=index)
 |  >>> df2 = DataFrame(np.random.randn(10, 5))
 |  >>> df3 = DataFrame(np.random.randn(10, 5),
 |  ...                 columns=['a', 'b', 'c', 'd', 'e'])
 |  
 |  See also
 |  --------
 |  DataFrame.from_records : constructor from tuples, also record arrays
 |  DataFrame.from_dict : from dicts of Series, arrays, or dicts
 |  DataFrame.from_items : from sequence of (key, value) pairs
 |  pandas.read_csv, pandas.read_table, pandas.read_clipboard
 |  
 |  Method resolution order:
 |      DataFrame
 |      pandas.core.generic.NDFrame
 |      pandas.core.base.PandasObject
 |      pandas.core.base.StringMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __add__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __and__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __and__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __div__ = __truediv__(self, other, axis=None, level=None, fill_value=None)
 |  
 |  __eq__(self, other)
 |      Wrapper for comparison method __eq__
 |  
 |  __floordiv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __floordiv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ge__(self, other)
 |      Wrapper for comparison method __ge__
 |  
 |  __getitem__(self, key)
 |  
 |  __gt__(self, other)
 |      Wrapper for comparison method __gt__
 |  
 |  __iadd__ = f(self, other)
 |  
 |  __imul__ = f(self, other)
 |  
 |  __init__(self, data=None, index=None, columns=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __ipow__ = f(self, other)
 |  
 |  __isub__ = f(self, other)
 |  
 |  __itruediv__ = f(self, other)
 |  
 |  __le__(self, other)
 |      Wrapper for comparison method __le__
 |  
 |  __len__(self)
 |      Returns length of info axis, but here we use the index
 |  
 |  __lt__(self, other)
 |      Wrapper for comparison method __lt__
 |  
 |  __mod__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __mod__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __mul__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __mul__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ne__(self, other)
 |      Wrapper for comparison method __ne__
 |  
 |  __or__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __or__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __pow__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __pow__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __radd__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __radd__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rand__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __rand__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rdiv__ = __rtruediv__(self, other, axis=None, level=None, fill_value=None)
 |  
 |  __rfloordiv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rfloordiv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rmod__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rmod__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rmul__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rmul__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ror__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __ror__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rpow__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rpow__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rsub__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rsub__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rtruediv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rtruediv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rxor__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __rxor__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __sub__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __truediv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __truediv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __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__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __xor__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  add(self, other, axis='columns', level=None, fill_value=None)
 |      Addition of dataframe and other, element-wise (binary operator `add`).
 |      
 |      Equivalent to ``dataframe + other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.radd
 |  
 |  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, 1, 'index', 'columns'}, default 0
 |          Filling axis, method and limit
 |      broadcast_axis : {0, 1, 'index', 'columns'}, default None
 |          Broadcast values along this axis, if aligning two objects of
 |          different dimensions
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Returns
 |      -------
 |      (left, right) : (DataFrame, 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), columns (1)}
 |      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 Series
 |      bool_only : boolean, default None
 |          Include only boolean data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      all : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      bool_only : boolean, default None
 |          Include only boolean data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      any : Series or DataFrame (if level specified)
 |  
 |  append(self, other, ignore_index=False, verify_integrity=False)
 |      Append rows of `other` to the end of this frame, returning a new
 |      object. Columns not in this frame are added as new columns.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame or Series/dict-like object, or list of these
 |          The data to append.
 |      ignore_index : boolean, default False
 |          If True, do not use the index labels.
 |      verify_integrity : boolean, default False
 |          If True, raise ValueError on creating index with duplicates.
 |      
 |      Returns
 |      -------
 |      appended : DataFrame
 |      
 |      Notes
 |      -----
 |      If a list of dict/series is passed and the keys are all contained in
 |      the DataFrame's index, the order of the columns in the resulting
 |      DataFrame will be unchanged.
 |      
 |      See also
 |      --------
 |      pandas.concat : General function to concatenate DataFrame, Series
 |          or Panel objects
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
 |      >>> df
 |         A  B
 |      0  1  2
 |      1  3  4
 |      >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
 |      >>> df.append(df2)
 |         A  B
 |      0  1  2
 |      1  3  4
 |      0  5  6
 |      1  7  8
 |      
 |      With `ignore_index` set to True:
 |      
 |      >>> df.append(df2, ignore_index=True)
 |         A  B
 |      0  1  2
 |      1  3  4
 |      2  5  6
 |      3  7  8
 |  
 |  apply(self, func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
 |      Applies function along input axis of DataFrame.
 |      
 |      Objects passed to functions are Series objects having index
 |      either the DataFrame's index (axis=0) or the columns (axis=1).
 |      Return type depends on whether passed function aggregates, or the
 |      reduce argument if the DataFrame is empty.
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Function to apply to each column/row
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          * 0 or 'index': apply function to each column
 |          * 1 or 'columns': apply function to each row
 |      broadcast : boolean, default False
 |          For aggregation functions, return object of same size with values
 |          propagated
 |      raw : boolean, default False
 |          If False, convert each row or column into a Series. If raw=True the
 |          passed function will receive ndarray objects instead. If you are
 |          just applying a NumPy reduction function this will achieve much
 |          better performance
 |      reduce : boolean or None, default None
 |          Try to apply reduction procedures. If the DataFrame is empty,
 |          apply will use reduce to determine whether the result should be a
 |          Series or a DataFrame. If reduce is None (the default), apply's
 |          return value will be guessed by calling func an empty Series (note:
 |          while guessing, exceptions raised by func will be ignored). If
 |          reduce is True a Series will always be returned, and if False a
 |          DataFrame will always be returned.
 |      args : tuple
 |          Positional arguments to pass to function in addition to the
 |          array/series
 |      Additional keyword arguments will be passed as keywords to the function
 |      
 |      Notes
 |      -----
 |      In the current implementation apply calls func twice on the
 |      first column/row to decide whether it can take a fast or slow
 |      code path. This can lead to unexpected behavior if func has
 |      side-effects, as they will take effect twice for the first
 |      column/row.
 |      
 |      Examples
 |      --------
 |      >>> df.apply(numpy.sqrt) # returns DataFrame
 |      >>> df.apply(numpy.sum, axis=0) # equiv to df.sum(0)
 |      >>> df.apply(numpy.sum, axis=1) # equiv to df.sum(1)
 |      
 |      See also
 |      --------
 |      DataFrame.applymap: For elementwise operations
 |      
 |      Returns
 |      -------
 |      applied : Series or DataFrame
 |  
 |  applymap(self, func)
 |      Apply a function to a DataFrame that is intended to operate
 |      elementwise, i.e. like doing map(func, series) for each series in the
 |      DataFrame
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Python function, returns a single value from a single value
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame(np.random.randn(3, 3))
 |      >>> df
 |          0         1          2
 |      0  -0.029638  1.081563   1.280300
 |      1   0.647747  0.831136  -1.549481
 |      2   0.513416 -0.884417   0.195343
 |      >>> df = df.applymap(lambda x: '%.2f' % x)
 |      >>> df
 |          0         1          2
 |      0  -0.03      1.08       1.28
 |      1   0.65      0.83      -1.55
 |      2   0.51     -0.88       0.20
 |      
 |      Returns
 |      -------
 |      applied : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.apply : For operations on rows/columns
 |  
 |  assign(self, **kwargs)
 |      Assign new columns to a DataFrame, returning a new object
 |      (a copy) with all the original columns in addition to the new ones.
 |      
 |      .. versionadded:: 0.16.0
 |      
 |      Parameters
 |      ----------
 |      kwargs : keyword, value pairs
 |          keywords are the column names. If the values are
 |          callable, they are computed on the DataFrame and
 |          assigned to the new columns. If the values are
 |          not callable, (e.g. a Series, scalar, or array),
 |          they are simply assigned.
 |      
 |      Returns
 |      -------
 |      df : DataFrame
 |          A new DataFrame with the new columns in addition to
 |          all the existing columns.
 |      
 |      Notes
 |      -----
 |      Since ``kwargs`` is a dictionary, the order of your
 |      arguments may not be preserved. The make things predicatable,
 |      the columns are inserted in alphabetical order, at the end of
 |      your DataFrame. Assigning multiple columns within the same
 |      ``assign`` is possible, but you cannot reference other columns
 |      created within the same ``assign`` call.
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'A': range(1, 11), 'B': np.random.randn(10)})
 |      
 |      Where the value is a callable, evaluated on `df`:
 |      
 |      >>> df.assign(ln_A = lambda x: np.log(x.A))
 |          A         B      ln_A
 |      0   1  0.426905  0.000000
 |      1   2 -0.780949  0.693147
 |      2   3 -0.418711  1.098612
 |      3   4 -0.269708  1.386294
 |      4   5 -0.274002  1.609438
 |      5   6 -0.500792  1.791759
 |      6   7  1.649697  1.945910
 |      7   8 -1.495604  2.079442
 |      8   9  0.549296  2.197225
 |      9  10 -0.758542  2.302585
 |      
 |      Where the value already exists and is inserted:
 |      
 |      >>> newcol = np.log(df['A'])
 |      >>> df.assign(ln_A=newcol)
 |          A         B      ln_A
 |      0   1  0.426905  0.000000
 |      1   2 -0.780949  0.693147
 |      2   3 -0.418711  1.098612
 |      3   4 -0.269708  1.386294
 |      4   5 -0.274002  1.609438
 |      5   6 -0.500792  1.791759
 |      6   7  1.649697  1.945910
 |      7   8 -1.495604  2.079442
 |      8   9  0.549296  2.197225
 |      9  10 -0.758542  2.302585
 |  
 |  boxplot(self, column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, **kwds)
 |      Make a box plot from DataFrame column optionally grouped by some columns or
 |      other inputs
 |      
 |      Parameters
 |      ----------
 |      data : the pandas object holding the data
 |      column : column name or list of names, or vector
 |          Can be any valid input to groupby
 |      by : string or sequence
 |          Column in the DataFrame to group by
 |      ax : Matplotlib axes object, optional
 |      fontsize : int or string
 |      rot : label rotation angle
 |      figsize : A tuple (width, height) in inches
 |      grid : Setting this to True will show the grid
 |      layout : tuple (optional)
 |          (rows, columns) for the layout of the plot
 |      return_type : {'axes', 'dict', 'both'}, default 'dict'
 |          The kind of object to return. 'dict' returns a dictionary
 |          whose values are the matplotlib Lines of the boxplot;
 |          'axes' returns the matplotlib axes the boxplot is drawn on;
 |          'both' returns a namedtuple with the axes and dict.
 |      
 |          When grouping with ``by``, a dict mapping columns to ``return_type``
 |          is returned.
 |      
 |      kwds : other plotting keyword arguments to be passed to matplotlib boxplot
 |             function
 |      
 |      Returns
 |      -------
 |      lines : dict
 |      ax : matplotlib Axes
 |      (ax, lines): namedtuple
 |      
 |      Notes
 |      -----
 |      Use ``return_type='dict'`` when you want to tweak the appearance
 |      of the lines after plotting. In this case a dict containing the Lines
 |      making up the boxes, caps, fliers, medians, and whiskers is returned.
 |  
 |  combine(self, other, func, fill_value=None, overwrite=True)
 |      Add two DataFrame objects and do not propagate NaN values, so if for a
 |      (column, time) one frame is missing a value, it will default to the
 |      other frame's value (which might be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      func : function
 |      fill_value : scalar value
 |      overwrite : boolean, default True
 |          If True then overwrite values for common keys in the calling frame
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  combineAdd(self, other)
 |      DEPRECATED. Use ``DataFrame.add(other, fill_value=0.)`` instead.
 |      
 |      Add two DataFrame objects and do not propagate
 |      NaN values, so if for a (column, time) one frame is missing a
 |      value, it will default to the other frame's value (which might
 |      be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.add
 |  
 |  combineMult(self, other)
 |      DEPRECATED. Use ``DataFrame.mul(other, fill_value=1.)`` instead.
 |      
 |      Multiply two DataFrame objects and do not propagate NaN values, so if
 |      for a (column, time) one frame is missing a value, it will default to
 |      the other frame's value (which might be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mul
 |  
 |  combine_first(self, other)
 |      Combine two DataFrame objects and default to non-null values in frame
 |      calling the method. Result index columns will be the union of the
 |      respective indexes and columns
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Examples
 |      --------
 |      a's values prioritized, use values from b to fill holes:
 |      
 |      >>> a.combine_first(b)
 |      
 |      
 |      Returns
 |      -------
 |      combined : DataFrame
 |  
 |  compound(self, axis=None, skipna=None, level=None)
 |      Return the compound percentage of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      compounded : Series or DataFrame (if level specified)
 |  
 |  corr(self, method='pearson', min_periods=1)
 |      Compute pairwise correlation of columns, excluding NA/null values
 |      
 |      Parameters
 |      ----------
 |      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 required per pair of columns
 |          to have a valid result. Currently only available for pearson
 |          and spearman correlation
 |      
 |      Returns
 |      -------
 |      y : DataFrame
 |  
 |  corrwith(self, other, axis=0, drop=False)
 |      Compute pairwise correlation between rows or columns of two DataFrame
 |      objects.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' to compute column-wise, 1 or 'columns' for row-wise
 |      drop : boolean, default False
 |          Drop missing indices from result, default returns union of all
 |      
 |      Returns
 |      -------
 |      correls : Series
 |  
 |  count(self, axis=0, level=None, numeric_only=False)
 |      Return Series with number of non-NA/null observations over requested
 |      axis. Works with non-floating point data as well (detects NaN and None)
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a DataFrame
 |      numeric_only : boolean, default False
 |          Include only float, int, boolean data
 |      
 |      Returns
 |      -------
 |      count : Series (or DataFrame if level specified)
 |  
 |  cov(self, min_periods=None)
 |      Compute pairwise covariance of columns, excluding NA/null values
 |      
 |      Parameters
 |      ----------
 |      min_periods : int, optional
 |          Minimum number of observations required per pair of columns
 |          to have a valid result.
 |      
 |      Returns
 |      -------
 |      y : DataFrame
 |      
 |      Notes
 |      -----
 |      `y` contains the covariance matrix of the DataFrame's time series.
 |      The covariance is normalized by N-1 (unbiased estimator).
 |  
 |  cummax = max(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative max over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      max : Series
 |  
 |  cummin = min(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative min over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      min : Series
 |  
 |  cumprod = prod(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative prod over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      prod : Series
 |  
 |  cumsum = sum(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative sum over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      sum : Series
 |  
 |  diff(self, periods=1, axis=0)
 |      1st discrete difference of object
 |      
 |      Parameters
 |      ----------
 |      periods : int, default 1
 |          Periods to shift for forming difference
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          Take difference over rows (0) or columns (1).
 |      
 |          .. versionadded: 0.16.1
 |      
 |      Returns
 |      -------
 |      diffed : DataFrame
 |  
 |  div = truediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  divide = truediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  dot(self, other)
 |      Matrix multiplication with DataFrame or Series objects
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame or Series
 |      
 |      Returns
 |      -------
 |      dot_product : DataFrame or Series
 |  
 |  drop_duplicates(self, subset=None, keep='first', inplace=False)
 |      Return DataFrame with duplicate rows removed, optionally only
 |      considering certain columns
 |      
 |      Parameters
 |      ----------
 |      subset : column label or sequence of labels, optional
 |          Only consider certain columns for identifying duplicates, by
 |          default use all of the columns
 |      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.
 |      take_last : deprecated
 |      inplace : boolean, default False
 |          Whether to drop duplicates in place or to return a copy
 |      
 |      Returns
 |      -------
 |      deduplicated : DataFrame
 |  
 |  dropna(self, axis=0, how='any', thresh=None, subset=None, inplace=False)
 |      Return object with labels on given axis omitted where alternately any
 |      or all of the data are missing
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, or tuple/list thereof
 |          Pass tuple or list to drop on multiple axes
 |      how : {'any', 'all'}
 |          * any : if any NA values are present, drop that label
 |          * all : if all values are NA, drop that label
 |      thresh : int, default None
 |          int value : require that many non-NA values
 |      subset : array-like
 |          Labels along other axis to consider, e.g. if you are dropping rows
 |          these would be a list of columns to include
 |      inplace : boolean, default False
 |          If True, do operation inplace and return None.
 |      
 |      Returns
 |      -------
 |      dropped : DataFrame
 |  
 |  duplicated(self, subset=None, keep='first')
 |      Return boolean Series denoting duplicate rows, optionally only
 |      considering certain columns
 |      
 |      Parameters
 |      ----------
 |      subset : column label or sequence of labels, optional
 |          Only consider certain columns for identifying duplicates, by
 |          default use all of the columns
 |      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``.
 |      take_last : deprecated
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods eq
 |  
 |  eval(self, expr, inplace=None, **kwargs)
 |      Evaluate an expression in the context of the calling DataFrame
 |      instance.
 |      
 |      Parameters
 |      ----------
 |      expr : string
 |          The expression string to evaluate.
 |      inplace : bool
 |          If the expression contains an assignment, whether to return a new
 |          DataFrame or mutate the existing.
 |      
 |          WARNING: inplace=None currently falls back to to True, but
 |          in a future version, will default to False.  Use inplace=True
 |          explicitly rather than relying on the default.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      kwargs : dict
 |          See the documentation for :func:`~pandas.eval` for complete details
 |          on the keyword arguments accepted by
 |          :meth:`~pandas.DataFrame.query`.
 |      
 |      Returns
 |      -------
 |      ret : ndarray, scalar, or pandas object
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.query
 |      pandas.DataFrame.assign
 |      pandas.eval
 |      
 |      Notes
 |      -----
 |      For more details see the API documentation for :func:`~pandas.eval`.
 |      For detailed examples see :ref:`enhancing performance with eval
 |      <enhancingperf.eval>`.
 |      
 |      Examples
 |      --------
 |      >>> from numpy.random import randn
 |      >>> from pandas import DataFrame
 |      >>> df = DataFrame(randn(10, 2), columns=list('ab'))
 |      >>> df.eval('a + b')
 |      >>> df.eval('c = a + b')
 |  
 |  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
 |      
 |      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, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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, 1, 'index', 'columns'}
 |      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.
 |      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 : DataFrame
 |  
 |  first_valid_index(self)
 |      Return label for first non-NA/null value
 |  
 |  floordiv(self, other, axis='columns', level=None, fill_value=None)
 |      Integer division of dataframe and other, element-wise (binary operator `floordiv`).
 |      
 |      Equivalent to ``dataframe // other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rfloordiv
 |  
 |  ge(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods ge
 |  
 |  get_value(self, index, col, takeable=False)
 |      Quickly retrieve single value at passed column and index
 |      
 |      Parameters
 |      ----------
 |      index : row label
 |      col : column label
 |      takeable : interpret the index/col as indexers, default False
 |      
 |      Returns
 |      -------
 |      value : scalar value
 |  
 |  gt(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods gt
 |  
 |  hist = hist_frame(data, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, **kwds)
 |      Draw histogram of the DataFrame's series using matplotlib / pylab.
 |      
 |      Parameters
 |      ----------
 |      data : DataFrame
 |      column : string or sequence
 |          If passed, will be used to limit data to a subset of columns
 |      by : object, optional
 |          If passed, then used to form histograms for separate groups
 |      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
 |      ax : matplotlib axes object, default None
 |      sharex : boolean, default True if ax is None else False
 |          In case subplots=True, share x axis and set some x axis labels to
 |          invisible; defaults to True if ax is None otherwise False if an ax
 |          is passed in; Be aware, that passing in both an ax and sharex=True
 |          will alter all x axis labels for all subplots in a figure!
 |      sharey : boolean, default False
 |          In case subplots=True, share y axis and set some y axis labels to
 |          invisible
 |      figsize : tuple
 |          The size of the figure to create in inches by default
 |      layout: (optional) a tuple (rows, columns) for the layout of the histograms
 |      bins: integer, default 10
 |          Number of histogram bins to be used
 |      kwds : other plotting keyword arguments
 |          To be passed to hist function
 |  
 |  icol(self, i)
 |      DEPRECATED. Use ``.iloc[:, i]`` instead
 |  
 |  idxmax(self, axis=0, skipna=True)
 |      Return index of first occurrence of maximum over requested axis.
 |      NA/null values are excluded.
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be first index.
 |      
 |      Returns
 |      -------
 |      idxmax : Series
 |      
 |      Notes
 |      -----
 |      This method is the DataFrame version of ``ndarray.argmax``.
 |      
 |      See Also
 |      --------
 |      Series.idxmax
 |  
 |  idxmin(self, axis=0, skipna=True)
 |      Return index of first occurrence of minimum over requested axis.
 |      NA/null values are excluded.
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      idxmin : Series
 |      
 |      Notes
 |      -----
 |      This method is the DataFrame version of ``ndarray.argmin``.
 |      
 |      See Also
 |      --------
 |      Series.idxmin
 |  
 |  iget_value(self, i, j)
 |      DEPRECATED. Use ``.iat[i, j]`` instead
 |  
 |  info(self, verbose=None, buf=None, max_cols=None, memory_usage=None, null_counts=None)
 |      Concise summary of a DataFrame.
 |      
 |      Parameters
 |      ----------
 |      verbose : {None, True, False}, optional
 |          Whether to print the full summary.
 |          None follows the `display.max_info_columns` setting.
 |          True or False overrides the `display.max_info_columns` setting.
 |      buf : writable buffer, defaults to sys.stdout
 |      max_cols : int, default None
 |          Determines whether full summary or short summary is printed.
 |          None follows the `display.max_info_columns` setting.
 |      memory_usage : boolean/string, default None
 |          Specifies whether total memory usage of the DataFrame
 |          elements (including index) should be displayed. None follows
 |          the `display.memory_usage` setting. True or False overrides
 |          the `display.memory_usage` setting. A value of 'deep' is equivalent
 |          of True, with deep introspection. Memory usage is shown in
 |          human-readable units (base-2 representation).
 |      null_counts : boolean, default None
 |          Whether to show the non-null counts
 |      
 |          - If None, then only show if the frame is smaller than
 |            max_info_rows and max_info_columns.
 |          - If True, always show counts.
 |          - If False, never show counts.
 |  
 |  insert(self, loc, column, value, allow_duplicates=False)
 |      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 : int, Series, or array-like
 |  
 |  irow(self, i, copy=False)
 |      DEPRECATED. Use ``.iloc[i]`` instead
 |  
 |  isin(self, values)
 |      Return boolean DataFrame showing whether each element in the
 |      DataFrame is contained in values.
 |      
 |      Parameters
 |      ----------
 |      values : iterable, Series, DataFrame or dictionary
 |          The result will only be true at a location if all the
 |          labels match. If `values` is a Series, that's the index. If
 |          `values` is a dictionary, the keys must be the column names,
 |          which must match. If `values` is a DataFrame,
 |          then both the index and column labels must match.
 |      
 |      Returns
 |      -------
 |      
 |      DataFrame of booleans
 |      
 |      Examples
 |      --------
 |      When ``values`` is a list:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': ['a', 'b', 'f']})
 |      >>> df.isin([1, 3, 12, 'a'])
 |             A      B
 |      0   True   True
 |      1  False  False
 |      2   True  False
 |      
 |      When ``values`` is a dict:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': [1, 4, 7]})
 |      >>> df.isin({'A': [1, 3], 'B': [4, 7, 12]})
 |             A      B
 |      0   True  False  # Note that B didn't match the 1 here.
 |      1  False   True
 |      2   True   True
 |      
 |      When ``values`` is a Series or DataFrame:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': ['a', 'b', 'f']})
 |      >>> other = DataFrame({'A': [1, 3, 3, 2], 'B': ['e', 'f', 'f', 'e']})
 |      >>> df.isin(other)
 |             A      B
 |      0   True  False
 |      1  False  False  # Column A in `other` has a 3, but not at index 1.
 |      2   True   True
 |  
 |  items = iteritems(self)
 |  
 |  iteritems(self)
 |      Iterator over (column name, Series) pairs.
 |      
 |      See also
 |      --------
 |      iterrows : Iterate over DataFrame rows as (index, Series) pairs.
 |      itertuples : Iterate over DataFrame rows as namedtuples of the values.
 |  
 |  iterrows(self)
 |      Iterate over DataFrame rows as (index, Series) pairs.
 |      
 |      Notes
 |      -----
 |      
 |      1. Because ``iterrows`` returns a Series for each row,
 |         it does **not** preserve dtypes across the rows (dtypes are
 |         preserved across columns for DataFrames). For example,
 |      
 |         >>> df = pd.DataFrame([[1, 1.5]], columns=['int', 'float'])
 |         >>> row = next(df.iterrows())[1]
 |         >>> row
 |         int      1.0
 |         float    1.5
 |         Name: 0, dtype: float64
 |         >>> print(row['int'].dtype)
 |         float64
 |         >>> print(df['int'].dtype)
 |         int64
 |      
 |         To preserve dtypes while iterating over the rows, it is better
 |         to use :meth:`itertuples` which returns namedtuples of the values
 |         and which is generally faster than ``iterrows``.
 |      
 |      2. You should **never modify** something you are iterating over.
 |         This is not guaranteed to work in all cases. Depending on the
 |         data types, the iterator returns a copy and not a view, and writing
 |         to it will have no effect.
 |      
 |      Returns
 |      -------
 |      it : generator
 |          A generator that iterates over the rows of the frame.
 |      
 |      See also
 |      --------
 |      itertuples : Iterate over DataFrame rows as namedtuples of the values.
 |      iteritems : Iterate over (column name, Series) pairs.
 |  
 |  itertuples(self, index=True, name='Pandas')
 |      Iterate over DataFrame rows as namedtuples, with index value as first
 |      element of the tuple.
 |      
 |      Parameters
 |      ----------
 |      index : boolean, default True
 |          If True, return the index as the first element of the tuple.
 |      name : string, default "Pandas"
 |          The name of the returned namedtuples or None to return regular
 |          tuples.
 |      
 |      Notes
 |      -----
 |      The column names will be renamed to positional names if they are
 |      invalid Python identifiers, repeated, or start with an underscore.
 |      With a large number of columns (>255), regular tuples are returned.
 |      
 |      See also
 |      --------
 |      iterrows : Iterate over DataFrame rows as (index, Series) pairs.
 |      iteritems : Iterate over (column name, Series) pairs.
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]},
 |                            index=['a', 'b'])
 |      >>> df
 |         col1  col2
 |      a     1   0.1
 |      b     2   0.2
 |      >>> for row in df.itertuples():
 |      ...     print(row)
 |      ...
 |      Pandas(Index='a', col1=1, col2=0.10000000000000001)
 |      Pandas(Index='b', col1=2, col2=0.20000000000000001)
 |  
 |  join(self, other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
 |      Join columns with other DataFrame either on index or on a key
 |      column. Efficiently Join multiple DataFrame objects by index at once by
 |      passing a list.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame, Series with name field set, or list of DataFrame
 |          Index should be similar to one of the columns in this one. If a
 |          Series is passed, its name attribute must be set, and that will be
 |          used as the column name in the resulting joined DataFrame
 |      on : column name, tuple/list of column names, or array-like
 |          Column(s) to use for joining, otherwise join on index. If multiples
 |          columns given, the passed DataFrame must have a MultiIndex. Can
 |          pass an array as the join key if not already contained in the
 |          calling DataFrame. Like an Excel VLOOKUP operation
 |      how : {'left', 'right', 'outer', 'inner'}
 |          How to handle indexes of the two objects. Default: 'left'
 |          for joining on index, None otherwise
 |      
 |          * left: use calling frame's index
 |          * right: use input frame's index
 |          * outer: form union of indexes
 |          * inner: use intersection of indexes
 |      lsuffix : string
 |          Suffix to use from left frame's overlapping columns
 |      rsuffix : string
 |          Suffix to use from right frame's overlapping columns
 |      sort : boolean, default False
 |          Order result DataFrame lexicographically by the join key. If False,
 |          preserves the index order of the calling (left) DataFrame
 |      
 |      Notes
 |      -----
 |      on, lsuffix, and rsuffix options are not supported when passing a list
 |      of DataFrame objects
 |      
 |      Returns
 |      -------
 |      joined : DataFrame
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      kurt : Series or DataFrame (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, axis='columns', level=None)
 |      Wrapper for flexible comparison methods le
 |  
 |  lookup(self, row_labels, col_labels)
 |      Label-based "fancy indexing" function for DataFrame.
 |      Given equal-length arrays of row and column labels, return an
 |      array of the values corresponding to each (row, col) pair.
 |      
 |      Parameters
 |      ----------
 |      row_labels : sequence
 |          The row labels to use for lookup
 |      col_labels : sequence
 |          The column labels to use for lookup
 |      
 |      Notes
 |      -----
 |      Akin to::
 |      
 |          result = []
 |          for row, col in zip(row_labels, col_labels):
 |              result.append(df.get_value(row, col))
 |      
 |      Examples
 |      --------
 |      values : ndarray
 |          The found values
 |  
 |  lt(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods lt
 |  
 |  mad(self, axis=None, skipna=None, level=None)
 |      Return the mean absolute deviation of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      mad : Series or DataFrame (if level specified)
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      max : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      mean : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      median : Series or DataFrame (if level specified)
 |  
 |  memory_usage(self, index=True, deep=False)
 |      Memory usage of DataFrame columns.
 |      
 |      Parameters
 |      ----------
 |      index : bool
 |          Specifies whether to include memory usage of DataFrame's
 |          index in returned Series. If `index=True` (default is False)
 |          the first index of the Series is `Index`.
 |      deep : bool
 |          Introspect the data deeply, interrogate
 |          `object` dtypes for system-level memory consumption
 |      
 |      Returns
 |      -------
 |      sizes : Series
 |          A series with column names as index and memory usage of
 |          columns with units of bytes.
 |      
 |      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
 |  
 |  merge(self, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False)
 |      Merge DataFrame objects by performing a database-style join operation by
 |      columns or indexes.
 |      
 |      If joining columns on columns, the DataFrame indexes *will be
 |      ignored*. Otherwise if joining indexes on indexes or indexes on a column or
 |      columns, the index will be passed on.
 |      
 |      Parameters
 |      ----------
 |      right : DataFrame
 |      how : {'left', 'right', 'outer', 'inner'}, default 'inner'
 |          * left: use only keys from left frame (SQL: left outer join)
 |          * right: use only keys from right frame (SQL: right outer join)
 |          * outer: use union of keys from both frames (SQL: full outer join)
 |          * inner: use intersection of keys from both frames (SQL: inner join)
 |      on : label or list
 |          Field names to join on. Must be found in both DataFrames. If on is
 |          None and not merging on indexes, then it merges on the intersection of
 |          the columns by default.
 |      left_on : label or list, or array-like
 |          Field names to join on in left DataFrame. Can be a vector or list of
 |          vectors of the length of the DataFrame to use a particular vector as
 |          the join key instead of columns
 |      right_on : label or list, or array-like
 |          Field names to join on in right DataFrame or vector/list of vectors per
 |          left_on docs
 |      left_index : boolean, default False
 |          Use the index from the left DataFrame as the join key(s). If it is a
 |          MultiIndex, the number of keys in the other DataFrame (either the index
 |          or a number of columns) must match the number of levels
 |      right_index : boolean, default False
 |          Use the index from the right DataFrame as the join key. Same caveats as
 |          left_index
 |      sort : boolean, default False
 |          Sort the join keys lexicographically in the result DataFrame
 |      suffixes : 2-length sequence (tuple, list, ...)
 |          Suffix to apply to overlapping column names in the left and right
 |          side, respectively
 |      copy : boolean, default True
 |          If False, do not copy data unnecessarily
 |      indicator : boolean or string, default False
 |          If True, adds a column to output DataFrame called "_merge" with
 |          information on the source of each row.
 |          If string, column with information on source of each row will be added to
 |          output DataFrame, and column will be named value of string.
 |          Information column is Categorical-type and takes on a value of "left_only"
 |          for observations whose merge key only appears in 'left' DataFrame,
 |          "right_only" for observations whose merge key only appears in 'right'
 |          DataFrame, and "both" if the observation's merge key is found in both.
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Examples
 |      --------
 |      
 |      >>> A              >>> B
 |          lkey value         rkey value
 |      0   foo  1         0   foo  5
 |      1   bar  2         1   bar  6
 |      2   baz  3         2   qux  7
 |      3   foo  4         3   bar  8
 |      
 |      >>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
 |         lkey  value_x  rkey  value_y
 |      0  foo   1        foo   5
 |      1  foo   4        foo   5
 |      2  bar   2        bar   6
 |      3  bar   2        bar   8
 |      4  baz   3        NaN   NaN
 |      5  NaN   NaN      qux   7
 |      
 |      Returns
 |      -------
 |      merged : DataFrame
 |          The output type will the be same as 'left', if it is a subclass
 |          of DataFrame.
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      min : Series or DataFrame (if level specified)
 |  
 |  mod(self, other, axis='columns', level=None, fill_value=None)
 |      Modulo of dataframe and other, element-wise (binary operator `mod`).
 |      
 |      Equivalent to ``dataframe % other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rmod
 |  
 |  mode(self, axis=0, numeric_only=False)
 |      Gets the mode(s) of each element along the axis selected. Empty if
 |      nothing has 2+ occurrences. Adds a row for each mode per label, fills
 |      in gaps with nan.
 |      
 |      Note that there could be multiple values returned for the selected
 |      axis (when more than one item share the maximum frequency), which is
 |      the reason why a dataframe is returned. If you want to impute missing
 |      values with the mode in a dataframe ``df``, you can just do this:
 |      ``df.fillna(df.mode().iloc[0])``
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          * 0 or 'index' : get mode of each column
 |          * 1 or 'columns' : get mode of each row
 |      numeric_only : boolean, default False
 |          if True, only apply to numeric columns
 |      
 |      Returns
 |      -------
 |      modes : DataFrame (sorted)
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({'A': [1, 2, 1, 2, 1, 2, 3]})
 |      >>> df.mode()
 |         A
 |      0  1
 |      1  2
 |  
 |  mul(self, other, axis='columns', level=None, fill_value=None)
 |      Multiplication of dataframe and other, element-wise (binary operator `mul`).
 |      
 |      Equivalent to ``dataframe * other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rmul
 |  
 |  multiply = mul(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  ne(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods ne
 |  
 |  nlargest(self, n, columns, keep='first')
 |      Get the rows of a DataFrame sorted by the `n` largest
 |      values of `columns`.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Number of items to retrieve
 |      columns : list or str
 |          Column name or names to order by
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'a': [1, 10, 8, 11, -1],
 |      ...                 'b': list('abdce'),
 |      ...                 'c': [1.0, 2.0, np.nan, 3.0, 4.0]})
 |      >>> df.nlargest(3, 'a')
 |          a  b   c
 |      3  11  c   3
 |      1  10  b   2
 |      2   8  d NaN
 |  
 |  nsmallest(self, n, columns, keep='first')
 |      Get the rows of a DataFrame sorted by the `n` smallest
 |      values of `columns`.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Number of items to retrieve
 |      columns : list or str
 |          Column name or names to order by
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'a': [1, 10, 8, 11, -1],
 |      ...                 'b': list('abdce'),
 |      ...                 'c': [1.0, 2.0, np.nan, 3.0, 4.0]})
 |      >>> df.nsmallest(3, 'a')
 |         a  b   c
 |      4 -1  e   4
 |      0  1  a   1
 |      2  8  d NaN
 |  
 |  pivot(self, index=None, columns=None, values=None)
 |      Reshape data (produce a "pivot" table) based on column values. Uses
 |      unique values from index / columns to form axes and return either
 |      DataFrame or Panel, depending on whether you request a single value
 |      column (DataFrame) or all columns (Panel)
 |      
 |      Parameters
 |      ----------
 |      index : string or object, optional
 |          Column name to use to make new frame's index. If None, uses
 |          existing index.
 |      columns : string or object
 |          Column name to use to make new frame's columns
 |      values : string or object, optional
 |          Column name to use for populating new frame's values
 |      
 |      Notes
 |      -----
 |      For finer-tuned control, see hierarchical indexing documentation along
 |      with the related stack/unstack methods
 |      
 |      Examples
 |      --------
 |      >>> df
 |          foo   bar  baz
 |      0   one   A    1.
 |      1   one   B    2.
 |      2   one   C    3.
 |      3   two   A    4.
 |      4   two   B    5.
 |      5   two   C    6.
 |      
 |      >>> df.pivot('foo', 'bar', 'baz')
 |           A   B   C
 |      one  1   2   3
 |      two  4   5   6
 |      
 |      >>> df.pivot('foo', 'bar')['baz']
 |           A   B   C
 |      one  1   2   3
 |      two  4   5   6
 |      
 |      Returns
 |      -------
 |      pivoted : DataFrame
 |          If no values column specified, will have hierarchically indexed
 |          columns
 |  
 |  pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
 |      Create a spreadsheet-style pivot table as a DataFrame. The levels in the
 |      pivot table will be stored in MultiIndex objects (hierarchical indexes) on
 |      the index and columns of the result DataFrame
 |      
 |      Parameters
 |      ----------
 |      data : DataFrame
 |      values : column to aggregate, optional
 |      index : column, Grouper, array, or list of the previous
 |          If an array is passed, it must be the same length as the data. The list
 |          can contain any of the other types (except list).
 |          Keys to group by on the pivot table index.  If an array is passed, it
 |          is being used as the same manner as column values.
 |      columns : column, Grouper, array, or list of the previous
 |          If an array is passed, it must be the same length as the data. The list
 |          can contain any of the other types (except list).
 |          Keys to group by on the pivot table column.  If an array is passed, it
 |          is being used as the same manner as column values.
 |      aggfunc : function or list of functions, default numpy.mean
 |          If list of functions passed, the resulting pivot table will have
 |          hierarchical columns whose top level are the function names (inferred
 |          from the function objects themselves)
 |      fill_value : scalar, default None
 |          Value to replace missing values with
 |      margins : boolean, default False
 |          Add all row / columns (e.g. for subtotal / grand totals)
 |      dropna : boolean, default True
 |          Do not include columns whose entries are all NaN
 |      margins_name : string, default 'All'
 |          Name of the row / column that will contain the totals
 |          when margins is True.
 |      
 |      Examples
 |      --------
 |      >>> df
 |         A   B   C      D
 |      0  foo one small  1
 |      1  foo one large  2
 |      2  foo one large  2
 |      3  foo two small  3
 |      4  foo two small  3
 |      5  bar one large  4
 |      6  bar one small  5
 |      7  bar two small  6
 |      8  bar two large  7
 |      
 |      >>> table = pivot_table(df, values='D', index=['A', 'B'],
 |      ...                     columns=['C'], aggfunc=np.sum)
 |      >>> table
 |                small  large
 |      foo  one  1      4
 |           two  6      NaN
 |      bar  one  5      4
 |           two  6      7
 |      
 |      Returns
 |      -------
 |      table : DataFrame
 |  
 |  pow(self, other, axis='columns', level=None, fill_value=None)
 |      Exponential power of dataframe and other, element-wise (binary operator `pow`).
 |      
 |      Equivalent to ``dataframe ** other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      prod : Series or DataFrame (if level specified)
 |  
 |  product = prod(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |  
 |  quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='linear')
 |      Return values at the given quantile over requested axis, a la
 |      numpy.percentile.
 |      
 |      Parameters
 |      ----------
 |      q : float or array-like, default 0.5 (50% quantile)
 |          0 <= q <= 1, the quantile(s) to compute
 |      axis : {0, 1, 'index', 'columns'} (default 0)
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      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
 |      -------
 |      quantiles : Series or DataFrame
 |      
 |          - If ``q`` is an array, a DataFrame will be returned where the
 |            index is ``q``, the columns are the columns of self, and the
 |            values are the quantiles.
 |          - If ``q`` is a float, a Series will be returned where the
 |            index is the columns of self and the values are the quantiles.
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),
 |                         columns=['a', 'b'])
 |      >>> df.quantile(.1)
 |      a    1.3
 |      b    3.7
 |      dtype: float64
 |      >>> df.quantile([.1, .5])
 |             a     b
 |      0.1  1.3   3.7
 |      0.5  2.5  55.0
 |  
 |  query(self, expr, inplace=False, **kwargs)
 |      Query the columns of a frame with a boolean expression.
 |      
 |      .. versionadded:: 0.13
 |      
 |      Parameters
 |      ----------
 |      expr : string
 |          The query string to evaluate.  You can refer to variables
 |          in the environment by prefixing them with an '@' character like
 |          ``@a + b``.
 |      inplace : bool
 |          Whether the query should modify the data in place or return
 |          a modified copy
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      kwargs : dict
 |          See the documentation for :func:`pandas.eval` for complete details
 |          on the keyword arguments accepted by :meth:`DataFrame.query`.
 |      
 |      Returns
 |      -------
 |      q : DataFrame
 |      
 |      Notes
 |      -----
 |      The result of the evaluation of this expression is first passed to
 |      :attr:`DataFrame.loc` and if that fails because of a
 |      multidimensional key (e.g., a DataFrame) then the result will be passed
 |      to :meth:`DataFrame.__getitem__`.
 |      
 |      This method uses the top-level :func:`pandas.eval` function to
 |      evaluate the passed query.
 |      
 |      The :meth:`~pandas.DataFrame.query` method uses a slightly
 |      modified Python syntax by default. For example, the ``&`` and ``|``
 |      (bitwise) operators have the precedence of their boolean cousins,
 |      :keyword:`and` and :keyword:`or`. This *is* syntactically valid Python,
 |      however the semantics are different.
 |      
 |      You can change the semantics of the expression by passing the keyword
 |      argument ``parser='python'``. This enforces the same semantics as
 |      evaluation in Python space. Likewise, you can pass ``engine='python'``
 |      to evaluate an expression using Python itself as a backend. This is not
 |      recommended as it is inefficient compared to using ``numexpr`` as the
 |      engine.
 |      
 |      The :attr:`DataFrame.index` and
 |      :attr:`DataFrame.columns` attributes of the
 |      :class:`~pandas.DataFrame` instance are placed in the query namespace
 |      by default, which allows you to treat both the index and columns of the
 |      frame as a column in the frame.
 |      The identifier ``index`` is used for the frame index; you can also
 |      use the name of the index to identify it in a query.
 |      
 |      For further details and examples see the ``query`` documentation in
 |      :ref:`indexing <indexing.query>`.
 |      
 |      See Also
 |      --------
 |      pandas.eval
 |      DataFrame.eval
 |      
 |      Examples
 |      --------
 |      >>> from numpy.random import randn
 |      >>> from pandas import DataFrame
 |      >>> df = DataFrame(randn(10, 2), columns=list('ab'))
 |      >>> df.query('a > b')
 |      >>> df[df.a > df.b]  # same result as the previous expression
 |  
 |  radd(self, other, axis='columns', level=None, fill_value=None)
 |      Addition of dataframe and other, element-wise (binary operator `radd`).
 |      
 |      Equivalent to ``other + dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.add
 |  
 |  rdiv = rtruediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  reindex(self, index=None, columns=None, **kwargs)
 |      Conform DataFrame 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, columns : 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.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                   404           0.08
 |      Chrome                 200           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 : DataFrame
 |  
 |  reindex_axis(self, labels, axis=0, method=None, level=None, copy=True, limit=None, fill_value=nan)
 |      Conform input object 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
 |      ----------
 |      labels : array-like
 |          New labels / index to conform to. Preferably an Index object to
 |          avoid duplicating data
 |      axis : {0, 1, 'index', 'columns'}
 |      method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}, optional
 |          Method to use for filling holes in reindexed DataFrame:
 |      
 |          * 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
 |      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
 |      --------
 |      >>> df.reindex_axis(['A', 'B', 'C'], axis=1)
 |      
 |      See Also
 |      --------
 |      reindex, reindex_like
 |      
 |      Returns
 |      -------
 |      reindexed : DataFrame
 |  
 |  rename(self, index=None, columns=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. Alternatively, change ``Series.name`` with a scalar
 |      value (Series only).
 |      
 |      Parameters
 |      ----------
 |      index, columns : 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 DataFrame. If True then value of copy is
 |          ignored.
 |      
 |      Returns
 |      -------
 |      renamed : DataFrame (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)
 |      ...
 |      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
 |  
 |  reorder_levels(self, order, axis=0)
 |      Rearrange index levels using input order.
 |      May not drop or duplicate levels
 |      
 |      Parameters
 |      ----------
 |      order : list of int or list of str
 |          List representing new level order. Reference level by number
 |          (position) or by key (label).
 |      axis : int
 |          Where to reorder levels.
 |      
 |      Returns
 |      -------
 |      type of caller (new object)
 |  
 |  reset_index(self, level=None, drop=False, inplace=False, col_level=0, col_fill='')
 |      For DataFrame with multi-level index, return new DataFrame with
 |      labeling information in the columns under the index names, defaulting
 |      to 'level_0', 'level_1', etc. if any are None. For a standard index,
 |      the index name will be used (if set), otherwise a default 'index' or
 |      'level_0' (if 'index' is already taken) will be used.
 |      
 |      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. This resets
 |          the index to the default integer index.
 |      inplace : boolean, default False
 |          Modify the DataFrame in place (do not create a new object)
 |      col_level : int or str, default 0
 |          If the columns have multiple levels, determines which level the
 |          labels are inserted into. By default it is inserted into the first
 |          level.
 |      col_fill : object, default ''
 |          If the columns have multiple levels, determines how the other
 |          levels are named. If None then the index name is repeated.
 |      
 |      Returns
 |      -------
 |      resetted : DataFrame
 |  
 |  rfloordiv(self, other, axis='columns', level=None, fill_value=None)
 |      Integer division of dataframe and other, element-wise (binary operator `rfloordiv`).
 |      
 |      Equivalent to ``other // dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.floordiv
 |  
 |  rmod(self, other, axis='columns', level=None, fill_value=None)
 |      Modulo of dataframe and other, element-wise (binary operator `rmod`).
 |      
 |      Equivalent to ``other % dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mod
 |  
 |  rmul(self, other, axis='columns', level=None, fill_value=None)
 |      Multiplication of dataframe and other, element-wise (binary operator `rmul`).
 |      
 |      Equivalent to ``other * dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mul
 |  
 |  rolling(self, window, min_periods=None, freq=None, center=False, win_type=None, axis=0)
 |      Provides rolling transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int
 |         Size of the moving window. This is the number of observations used for
 |         calculating the statistic.
 |      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.
 |      win_type : string, default None
 |          prove a window type, see the notes below
 |      axis : int, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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`).
 |      
 |      The recognized window 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, out=None)
 |      Round a DataFrame to a variable number of decimal places.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      decimals : int, dict, Series
 |          Number of decimal places to round each column to. If an int is
 |          given, round each column to the same number of places.
 |          Otherwise dict and Series round to variable numbers of places.
 |          Column names should be in the keys if `decimals` is a
 |          dict-like, or in the index if `decimals` is a Series. Any
 |          columns not included in `decimals` will be left as is. Elements
 |          of `decimals` which are not columns of the input will be
 |          ignored.
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame(np.random.random([3, 3]),
 |      ...     columns=['A', 'B', 'C'], index=['first', 'second', 'third'])
 |      >>> df
 |                     A         B         C
 |      first   0.028208  0.992815  0.173891
 |      second  0.038683  0.645646  0.577595
 |      third   0.877076  0.149370  0.491027
 |      >>> df.round(2)
 |                 A     B     C
 |      first   0.03  0.99  0.17
 |      second  0.04  0.65  0.58
 |      third   0.88  0.15  0.49
 |      >>> df.round({'A': 1, 'C': 2})
 |                A         B     C
 |      first   0.0  0.992815  0.17
 |      second  0.0  0.645646  0.58
 |      third   0.9  0.149370  0.49
 |      >>> decimals = pd.Series([1, 0, 2], index=['A', 'B', 'C'])
 |      >>> df.round(decimals)
 |                A  B     C
 |      first   0.0  1  0.17
 |      second  0.0  1  0.58
 |      third   0.9  0  0.49
 |      
 |      Returns
 |      -------
 |      DataFrame object
 |      
 |      See Also
 |      --------
 |      numpy.around
 |  
 |  rpow(self, other, axis='columns', level=None, fill_value=None)
 |      Exponential power of dataframe and other, element-wise (binary operator `rpow`).
 |      
 |      Equivalent to ``other ** dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.pow
 |  
 |  rsub(self, other, axis='columns', level=None, fill_value=None)
 |      Subtraction of dataframe and other, element-wise (binary operator `rsub`).
 |      
 |      Equivalent to ``other - dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.sub
 |  
 |  rtruediv(self, other, axis='columns', level=None, fill_value=None)
 |      Floating division of dataframe and other, element-wise (binary operator `rtruediv`).
 |      
 |      Equivalent to ``other / dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.truediv
 |  
 |  select_dtypes(self, include=None, exclude=None)
 |      Return a subset of a DataFrame including/excluding columns based on
 |      their ``dtype``.
 |      
 |      Parameters
 |      ----------
 |      include, exclude : list-like
 |          A list of dtypes or strings to be included/excluded. You must pass
 |          in a non-empty sequence for at least one of these.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          * If both of ``include`` and ``exclude`` are empty
 |          * If ``include`` and ``exclude`` have overlapping elements
 |          * If any kind of string dtype is passed in.
 |      TypeError
 |          * If either of ``include`` or ``exclude`` is not a sequence
 |      
 |      Returns
 |      -------
 |      subset : DataFrame
 |          The subset of the frame including the dtypes in ``include`` and
 |          excluding the dtypes in ``exclude``.
 |      
 |      Notes
 |      -----
 |      * To select all *numeric* types use the numpy dtype ``numpy.number``
 |      * To select strings you must use the ``object`` dtype, but note that
 |        this will return *all* object dtype columns
 |      * See the `numpy dtype hierarchy
 |        <http://docs.scipy.org/doc/numpy/reference/arrays.scalars.html>`__
 |      * To select Pandas categorical dtypes, use 'category'
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({'a': np.random.randn(6).astype('f4'),
 |      ...                    'b': [True, False] * 3,
 |      ...                    'c': [1.0, 2.0] * 3})
 |      >>> df
 |              a      b  c
 |      0  0.3962   True  1
 |      1  0.1459  False  2
 |      2  0.2623   True  1
 |      3  0.0764  False  2
 |      4 -0.9703   True  1
 |      5 -1.2094  False  2
 |      >>> df.select_dtypes(include=['float64'])
 |         c
 |      0  1
 |      1  2
 |      2  1
 |      3  2
 |      4  1
 |      5  2
 |      >>> df.select_dtypes(exclude=['floating'])
 |             b
 |      0   True
 |      1  False
 |      2   True
 |      3  False
 |      4   True
 |      5  False
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sem : Series or DataFrame (if level specified)
 |  
 |  set_index(self, keys, drop=True, append=False, inplace=False, verify_integrity=False)
 |      Set the DataFrame index (row labels) using one or more existing
 |      columns. By default yields a new object.
 |      
 |      Parameters
 |      ----------
 |      keys : column label or list of column labels / arrays
 |      drop : boolean, default True
 |          Delete columns to be used as the new index
 |      append : boolean, default False
 |          Whether to append columns to existing index
 |      inplace : boolean, default False
 |          Modify the DataFrame in place (do not create a new object)
 |      verify_integrity : boolean, default False
 |          Check the new index for duplicates. Otherwise defer the check until
 |          necessary. Setting to False will improve the performance of this
 |          method
 |      
 |      Examples
 |      --------
 |      >>> indexed_df = df.set_index(['A', 'B'])
 |      >>> indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])
 |      >>> indexed_df3 = df.set_index([[0, 1, 2, 0, 1, 2]])
 |      
 |      Returns
 |      -------
 |      dataframe : DataFrame
 |  
 |  set_value(self, index, col, value, takeable=False)
 |      Put single value at passed column and index
 |      
 |      Parameters
 |      ----------
 |      index : row label
 |      col : column label
 |      value : scalar value
 |      takeable : interpret the index/col as indexers, default False
 |      
 |      Returns
 |      -------
 |      frame : DataFrame
 |          If label pair is contained, will be reference to calling DataFrame,
 |          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 datetools module or time rule (e.g. 'EOM').
 |          See Notes.
 |      axis : {0, 1, 'index', 'columns'}
 |      
 |      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 : DataFrame
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      skew : Series or DataFrame (if level specified)
 |  
 |  sort(self, columns=None, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 |      DEPRECATED: use :meth:`DataFrame.sort_values`
 |      
 |      Sort DataFrame either by labels (along either axis) or by the values in
 |      column(s)
 |      
 |      Parameters
 |      ----------
 |      columns : object
 |          Column name(s) in frame. Accepts a column name or a list
 |          for a nested sort. A tuple will be interpreted as the
 |          levels of a multi-index.
 |      ascending : boolean or list, default True
 |          Sort ascending vs. descending. Specify list for multiple sort
 |          orders
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          Sort index/rows versus columns
 |      inplace : boolean, default False
 |          Sort the DataFrame without creating a new instance
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          This option is only applied when sorting on a single column or
 |          label.
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      
 |      Examples
 |      --------
 |      >>> result = df.sort(['A', 'B'], ascending=[1, 0])
 |      
 |      Returns
 |      -------
 |      sorted : DataFrame
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
 |      Sort object by labels (along an axis)
 |      
 |      Parameters
 |      ----------
 |      axis : index, columns 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
 |          if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      sort_remaining : bool
 |          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 : DataFrame
 |  
 |  sort_values(self, by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 |      Sort by the values along either axis
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      by : string name or list of names which refer to the axis items
 |      axis : index, columns to direct sorting
 |      ascending : bool or list of bool
 |           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
 |           if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      
 |      Returns
 |      -------
 |      sorted_obj : DataFrame
 |  
 |  sortlevel(self, level=0, axis=0, ascending=True, inplace=False, sort_remaining=True)
 |      Sort multilevel index by chosen axis and primary level. Data will be
 |      lexicographically sorted by the chosen level followed by the other
 |      levels (in order)
 |      
 |      Parameters
 |      ----------
 |      level : int
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |      ascending : boolean, default True
 |      inplace : boolean, default False
 |          Sort the DataFrame without creating a new instance
 |      sort_remaining : boolean, default True
 |          Sort by the other levels too.
 |      
 |      Returns
 |      -------
 |      sorted : DataFrame
 |      
 |      See Also
 |      --------
 |      DataFrame.sort_index(level=...)
 |  
 |  stack(self, level=-1, dropna=True)
 |      Pivot a level of the (possibly hierarchical) column labels, returning a
 |      DataFrame (or Series in the case of an object with a single level of
 |      column labels) having a hierarchical index with a new inner-most level
 |      of row labels.
 |      The level involved will automatically get sorted.
 |      
 |      Parameters
 |      ----------
 |      level : int, string, or list of these, default last level
 |          Level(s) to stack, can pass level name
 |      dropna : boolean, default True
 |          Whether to drop rows in the resulting Frame/Series with no valid
 |          values
 |      
 |      Examples
 |      ----------
 |      >>> s
 |           a   b
 |      one  1.  2.
 |      two  3.  4.
 |      
 |      >>> s.stack()
 |      one a    1
 |          b    2
 |      two a    3
 |          b    4
 |      
 |      Returns
 |      -------
 |      stacked : DataFrame or Series
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      std : Series or DataFrame (if level specified)
 |  
 |  sub(self, other, axis='columns', level=None, fill_value=None)
 |      Subtraction of dataframe and other, element-wise (binary operator `sub`).
 |      
 |      Equivalent to ``dataframe - other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rsub
 |  
 |  subtract = sub(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sum : Series or DataFrame (if level specified)
 |  
 |  swaplevel(self, i, j, axis=0)
 |      Swap levels i and j in a MultiIndex on a particular axis
 |      
 |      Parameters
 |      ----------
 |      i, j : int, string (can be mixed)
 |          Level of index to be swapped. Can pass level name as string.
 |      
 |      Returns
 |      -------
 |      swapped : type of caller (new object)
 |  
 |  to_csv(self, path_or_buf=None, sep=',', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression=None, quoting=None, quotechar='"', line_terminator='\n', chunksize=None, tupleize_cols=False, date_format=None, doublequote=True, escapechar=None, decimal='.', **kwds)
 |      Write DataFrame to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : string or file handle, default None
 |          File path or object, if None is provided the result is returned as
 |          a string.
 |      sep : character, default ','
 |          Field delimiter for the output file.
 |      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, or False, 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.  If
 |          False do not print fields for index names. Use index_label=False
 |          for easier importing in R
 |      nanRep : None
 |          deprecated, use na_rep
 |      mode : str
 |          Python write mode, default 'w'
 |      encoding : string, optional
 |          A string representing the encoding to use in the output file,
 |          defaults to 'ascii' on Python 2 and 'utf-8' on Python 3.
 |      compression : string, optional
 |          a string representing the compression to use in the output file,
 |          allowed values are 'gzip', 'bz2',
 |          only used when the first argument is a filename
 |      line_terminator : string, default '\n'
 |          The newline character or character sequence to use in the output
 |          file
 |      quoting : optional constant from csv module
 |          defaults to csv.QUOTE_MINIMAL
 |      quotechar : string (length 1), default '"'
 |          character used to quote fields
 |      doublequote : boolean, default True
 |          Control quoting of `quotechar` inside a field
 |      escapechar : string (length 1), default None
 |          character used to escape `sep` and `quotechar` when appropriate
 |      chunksize : int or None
 |          rows to write at a time
 |      tupleize_cols : boolean, default False
 |          write multi_index columns as a list of tuples (if True)
 |          or new (expanded format) if False)
 |      date_format : string, default None
 |          Format string for datetime objects
 |      decimal: string, default '.'
 |          Character recognized as decimal separator. E.g. use ',' for
 |          European data
 |      
 |          .. versionadded:: 0.16.0
 |  
 |  to_dict(self, orient='dict')
 |      Convert DataFrame to dictionary.
 |      
 |      Parameters
 |      ----------
 |      orient : str {'dict', 'list', 'series', 'split', 'records', 'index'}
 |          Determines the type of the values of the dictionary.
 |      
 |          - dict (default) : dict like {column -> {index -> value}}
 |          - list : dict like {column -> [values]}
 |          - series : dict like {column -> Series(values)}
 |          - split : dict like
 |            {index -> [index], columns -> [columns], data -> [values]}
 |          - records : list like
 |            [{column -> value}, ... , {column -> value}]
 |          - index : dict like {index -> {column -> value}}
 |      
 |            .. versionadded:: 0.17.0
 |      
 |          Abbreviations are allowed. `s` indicates `series` and `sp`
 |          indicates `split`.
 |      
 |      Returns
 |      -------
 |      result : dict like {column -> {index -> value}}
 |  
 |  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 DataFrame to a excel sheet
 |      
 |      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)
 |      
 |      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 = 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_gbq(self, destination_table, project_id, chunksize=10000, verbose=True, reauth=False, if_exists='fail', private_key=None)
 |      Write a DataFrame to a Google BigQuery table.
 |      
 |      THIS IS AN EXPERIMENTAL LIBRARY
 |      
 |      Parameters
 |      ----------
 |      dataframe : DataFrame
 |          DataFrame to be written
 |      destination_table : string
 |          Name of table to be written, in the form 'dataset.tablename'
 |      project_id : str
 |          Google BigQuery Account project ID.
 |      chunksize : int (default 10000)
 |          Number of rows to be inserted in each chunk from the dataframe.
 |      verbose : boolean (default True)
 |          Show percentage complete
 |      reauth : boolean (default False)
 |          Force Google BigQuery to reauthenticate the user. This is useful
 |          if multiple accounts are used.
 |      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.
 |      private_key : str (optional)
 |          Service account private key in JSON format. Can be file path
 |          or string contents. This is useful for remote server
 |          authentication (eg. jupyter iPython notebook on remote host)
 |      
 |          .. versionadded:: 0.17.0
 |  
 |  to_html(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, bold_rows=True, classes=None, escape=True, max_rows=None, max_cols=None, show_dimensions=False, notebook=False, decimal='.')
 |      Render a DataFrame as an HTML table.
 |      
 |      `to_html`-specific options:
 |      
 |      bold_rows : boolean, default True
 |          Make the row labels bold in the output
 |      classes : str or list or tuple, default None
 |          CSS class(es) to apply to the resulting html table
 |      escape : boolean, default True
 |          Convert the characters <, >, and & to HTML-safe sequences.=
 |      max_rows : int, optional
 |          Maximum number of rows to show before truncating. If None, show
 |          all.
 |      max_cols : int, optional
 |          Maximum number of columns to show before truncating. If None, show
 |          all.
 |      decimal : string, default '.'
 |          Character recognized as decimal separator, e.g. ',' in Europe
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      justify : {'left', 'right'}, default None
 |          Left or right-justify the column labels. If None uses the option from
 |          the print configuration (controlled by set_option), 'right' out
 |          of the box.
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_latex(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=True, column_format=None, longtable=None, escape=None, encoding=None, decimal='.')
 |      Render a DataFrame to a tabular environment table. You can splice
 |      this into a LaTeX document. Requires \usepackage{booktabs}.
 |      
 |      `to_latex`-specific options:
 |      
 |      bold_rows : boolean, default True
 |          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
 |          Default encoding is ascii in Python 2 and utf-8 in Python 3
 |      decimal : string, default '.'
 |          Character recognized as decimal separator, e.g. ',' in Europe
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_panel(self)
 |      Transform long (stacked) format (DataFrame) into wide (3D, Panel)
 |      format.
 |      
 |      Currently the index of the DataFrame must be a 2-level MultiIndex. This
 |      may be generalized later
 |      
 |      Returns
 |      -------
 |      panel : Panel
 |  
 |  to_period(self, freq=None, axis=0, copy=True)
 |      Convert DataFrame from DatetimeIndex to PeriodIndex with desired
 |      frequency (inferred from index if not passed)
 |      
 |      Parameters
 |      ----------
 |      freq : string, default
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          The axis to convert (the index by default)
 |      copy : boolean, default True
 |          If False then underlying input data is not copied
 |      
 |      Returns
 |      -------
 |      ts : TimeSeries with PeriodIndex
 |  
 |  to_records(self, index=True, convert_datetime64=True)
 |      Convert DataFrame to record array. Index will be put in the
 |      'index' field of the record array if requested
 |      
 |      Parameters
 |      ----------
 |      index : boolean, default True
 |          Include index in resulting record array, stored in 'index' field
 |      convert_datetime64 : boolean, default True
 |          Whether to convert the index to datetime.datetime if it is a
 |          DatetimeIndex
 |      
 |      Returns
 |      -------
 |      y : recarray
 |  
 |  to_sparse(self, fill_value=None, kind='block')
 |      Convert to SparseDataFrame
 |      
 |      Parameters
 |      ----------
 |      fill_value : float, default NaN
 |      kind : {'block', 'integer'}
 |      
 |      Returns
 |      -------
 |      y : SparseDataFrame
 |  
 |  to_stata(self, fname, convert_dates=None, write_index=True, encoding='latin-1', byteorder=None, time_stamp=None, data_label=None)
 |      A class for writing Stata binary dta files from array-like objects
 |      
 |      Parameters
 |      ----------
 |      fname : file path or buffer
 |          Where to save the dta file.
 |      convert_dates : dict
 |          Dictionary mapping column of datetime types to the stata internal
 |          format that you want to use for the dates. Options are
 |          'tc', 'td', 'tm', 'tw', 'th', 'tq', 'ty'. Column can be either a
 |          number or a name.
 |      encoding : str
 |          Default is latin-1. Note that Stata does not support unicode.
 |      byteorder : str
 |          Can be ">", "<", "little", or "big". The default is None which uses
 |          `sys.byteorder`
 |      
 |      Examples
 |      --------
 |      >>> writer = StataWriter('./data_file.dta', data)
 |      >>> writer.write_file()
 |      
 |      Or with dates
 |      
 |      >>> writer = StataWriter('./date_data_file.dta', data, {2 : 'tw'})
 |      >>> writer.write_file()
 |  
 |  to_string(self, buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, line_width=None, max_rows=None, max_cols=None, show_dimensions=False)
 |      Render a DataFrame to a console-friendly tabular output.
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      justify : {'left', 'right'}, default None
 |          Left or right-justify the column labels. If None uses the option from
 |          the print configuration (controlled by set_option), 'right' out
 |          of the box.
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_timestamp(self, freq=None, how='start', axis=0, 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
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          The axis to convert (the index by default)
 |      copy : boolean, default True
 |          If false then underlying input data is not copied
 |      
 |      Returns
 |      -------
 |      df : DataFrame with DatetimeIndex
 |  
 |  to_wide = wrapper(*args, **kwargs)
 |  
 |  transpose(self)
 |      Transpose index and columns
 |  
 |  truediv(self, other, axis='columns', level=None, fill_value=None)
 |      Floating division of dataframe and other, element-wise (binary operator `truediv`).
 |      
 |      Equivalent to ``dataframe / other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rtruediv
 |  
 |  unstack(self, level=-1, fill_value=None)
 |      Pivot a level of the (necessarily hierarchical) index labels, returning
 |      a DataFrame having a new level of column labels whose inner-most level
 |      consists of the pivoted index labels. If the index is not a MultiIndex,
 |      the output will be a Series (the analogue of stack when the columns are
 |      not a MultiIndex).
 |      The level involved will automatically get sorted.
 |      
 |      Parameters
 |      ----------
 |      level : int, string, or list of these, default -1 (last level)
 |          Level(s) of index to unstack, can pass level name
 |      fill_value : replace NaN with this value if the unstack produces
 |          missing values
 |      
 |          .. versionadded: 0.18.0
 |      
 |      See also
 |      --------
 |      DataFrame.pivot : Pivot a table based on column values.
 |      DataFrame.stack : Pivot a level of the column labels (inverse operation
 |          from `unstack`).
 |      
 |      Examples
 |      --------
 |      >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
 |      ...                                    ('two', 'a'), ('two', 'b')])
 |      >>> s = pd.Series(np.arange(1.0, 5.0), index=index)
 |      >>> s
 |      one  a   1
 |           b   2
 |      two  a   3
 |           b   4
 |      dtype: float64
 |      
 |      >>> s.unstack(level=-1)
 |           a   b
 |      one  1  2
 |      two  3  4
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a  1   3
 |      b  2   4
 |      
 |      >>> df = s.unstack(level=0)
 |      >>> df.unstack()
 |      one  a  1.
 |           b  3.
 |      two  a  2.
 |           b  4.
 |      
 |      Returns
 |      -------
 |      unstacked : DataFrame or Series
 |  
 |  update(self, other, join='left', overwrite=True, filter_func=None, raise_conflict=False)
 |      Modify DataFrame in place using non-NA values from passed
 |      DataFrame. Aligns on indices
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame, or object coercible into a DataFrame
 |      join : {'left'}, default 'left'
 |      overwrite : boolean, default True
 |          If True then overwrite values for common keys in the calling frame
 |      filter_func : callable(1d-array) -> 1d-array<boolean>, default None
 |          Can choose to replace values other than NA. Return True for values
 |          that should be updated
 |      raise_conflict : boolean
 |          If True, will raise an error if the DataFrame and other both
 |          contain data in the same place.
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      var : Series or DataFrame (if level specified)
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_csv(path, header=0, sep=',', index_col=0, parse_dates=True, encoding=None, tupleize_cols=False, 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 DataFrame of time series data.
 |      
 |      This method only differs from the preferred :func:`pandas.read_csv`
 |      in some defaults:
 |      
 |      - `index_col` is ``0`` instead of ``None`` (take first column as index
 |        by default)
 |      - `parse_dates` is ``True`` instead of ``False`` (try parsing the index
 |        as datetime by default)
 |      
 |      So a ``pd.DataFrame.from_csv(path)`` can be replaced by
 |      ``pd.read_csv(path, index_col=0, parse_dates=True)``.
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO
 |      header : int, default 0
 |          Row to use as header (skip prior rows)
 |      sep : string, default ','
 |          Field delimiter
 |      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
 |      parse_dates : boolean, default True
 |          Parse dates. Different default from read_table
 |      tupleize_cols : boolean, default False
 |          write multi_index columns as a list of tuples (if True)
 |          or new (expanded format) if False)
 |      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 : DataFrame
 |  
 |  from_dict(data, orient='columns', dtype=None) from builtins.type
 |      Construct DataFrame from dict of array-like or dicts
 |      
 |      Parameters
 |      ----------
 |      data : dict
 |          {field : array-like} or {field : dict}
 |      orient : {'columns', 'index'}, default 'columns'
 |          The "orientation" of the data. If the keys of the passed dict
 |          should be the columns of the resulting DataFrame, pass 'columns'
 |          (default). Otherwise if the keys should be rows, pass 'index'.
 |      dtype : dtype, default None
 |          Data type to force, otherwise infer
 |      
 |      Returns
 |      -------
 |      DataFrame
 |  
 |  from_items(items, columns=None, orient='columns') from builtins.type
 |      Convert (key, value) pairs to DataFrame. The keys will be the axis
 |      index (usually the columns, but depends on the specified
 |      orientation). The values should be arrays or Series.
 |      
 |      Parameters
 |      ----------
 |      items : sequence of (key, value) pairs
 |          Values should be arrays or Series.
 |      columns : sequence of column labels, optional
 |          Must be passed if orient='index'.
 |      orient : {'columns', 'index'}, default 'columns'
 |          The "orientation" of the data. If the keys of the
 |          input correspond to column labels, pass 'columns'
 |          (default). Otherwise if the keys correspond to the index,
 |          pass 'index'.
 |      
 |      Returns
 |      -------
 |      frame : DataFrame
 |  
 |  from_records(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None) from builtins.type
 |      Convert structured or record ndarray to DataFrame
 |      
 |      Parameters
 |      ----------
 |      data : ndarray (structured dtype), list of tuples, dict, or DataFrame
 |      index : string, list of fields, array-like
 |          Field of array to use as the index, alternately a specific set of
 |          input labels to use
 |      exclude : sequence, default None
 |          Columns or fields to exclude
 |      columns : sequence, default None
 |          Column names to use. If the passed data do not have names
 |          associated with them, this argument provides names for the
 |          columns. Otherwise this argument indicates the order of the columns
 |          in the result (any names not found in the data will become all-NA
 |          columns)
 |      coerce_float : boolean, default False
 |          Attempt to convert values to non-string, non-numeric objects (like
 |          decimal.Decimal) to floating point, useful for SQL result sets
 |      
 |      Returns
 |      -------
 |      df : DataFrame
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Transpose index and columns
 |  
 |  axes
 |      Return a list with the row axis labels and column axis labels as the
 |      only members. They are returned in that order.
 |  
 |  columns
 |  
 |  index
 |  
 |  shape
 |      Return a tuple representing the dimensionality of the DataFrame.
 |  
 |  style
 |      Property returning a Styler object containing methods for
 |      building a styled HTML representation fo the DataFrame.
 |      
 |      See Also
 |      --------
 |      pandas.core.style.Styler
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  plot = <class 'pandas.tools.plotting.FramePlotMethods'>
 |      DataFrame plotting accessor and method
 |      
 |      Examples
 |      --------
 |      >>> df.plot.line()
 |      >>> df.plot.scatter('x', 'y')
 |      >>> df.plot.hexbin()
 |      
 |      These plotting methods can also be accessed by calling the accessor as a
 |      method with the ``kind`` argument:
 |      ``df.plot(kind='line')`` is equivalent to ``df.plot.line()``
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.generic.NDFrame:
 |  
 |  __abs__(self)
 |  
 |  __array__(self, dtype=None)
 |  
 |  __array_wrap__(self, result, context=None)
 |  
 |  __bool__ = __nonzero__(self)
 |  
 |  __contains__(self, key)
 |      True if the key is in the info axis
 |  
 |  __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)
 |  
 |  __iter__(self)
 |      Iterate over infor axis
 |  
 |  __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.
 |      
 |      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)
 |      Convert all TimeSeries inside to specified frequency using DateOffset
 |      objects. Optionally provide fill method to pad/backfill missing values.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill', 'bfill', 'pad', 'ffill', 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 method
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |  
 |  astype(self, dtype, copy=True, raise_on_error=True, **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : numpy.dtype or Python type
 |      raise_on_error : raise on invalid input
 |      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 NDFrame.fillna(method='bfill')
 |  
 |  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, out=None, axis=None)
 |      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)
 |      Compute NDFrame with "consolidated" internals (data of each dtype
 |      grouped together in a single ndarray). Mainly an internal API function,
 |      but available here to the savvy user
 |      
 |      Parameters
 |      ----------
 |      inplace : boolean, default False
 |          If False return new object, otherwise modify existing object
 |      
 |      Returns
 |      -------
 |      consolidated : type of caller
 |  
 |  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 object
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, i.e. also copy data
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generate various summary statistics, excluding NaN values.
 |      
 |      Parameters
 |      ----------
 |      percentiles : array-like, optional
 |          The percentiles to include in the output. Should all
 |          be in the interval [0, 1]. By default `percentiles` is
 |          [.25, .5, .75], returning the 25th, 50th, and 75th percentiles.
 |      include, exclude : list-like, 'all', or None (default)
 |          Specify the form of the returned result. Either:
 |      
 |          - None to both (default). The result will include only
 |            numeric-typed columns or, if none are, only categorical columns.
 |          - A list of dtypes or strings to be included/excluded.
 |            To select all numeric types use numpy numpy.number. To select
 |            categorical objects use type object. See also the select_dtypes
 |            documentation. eg. df.describe(include=['O'])
 |          - If include is the string 'all', the output column-set will
 |            match the input one.
 |      
 |      Returns
 |      -------
 |      summary: NDFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      The output DataFrame index depends on the requested dtypes:
 |      
 |      For numeric dtypes, it will include: count, mean, std, min,
 |      max, and lower, 50, and upper percentiles.
 |      
 |      For object dtypes (e.g. timestamps or strings), the index
 |      will include the count, unique, most common, and frequency of the
 |      most common. Timestamps also include the first and last items.
 |      
 |      For mixed dtypes, the index will be the union of the corresponding
 |      output types. Non-applicable entries will be filled with NaN.
 |      Note that mixed-dtype outputs can only be returned from mixed-dtype
 |      inputs and appropriate use of the include/exclude arguments.
 |      
 |      If multiple values have the highest count, then the
 |      `count` and `most common` pair will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      The include, exclude arguments are ignored for Series.
 |      
 |      See Also
 |      --------
 |      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 NDFrame.fillna(method='ffill')
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Restrict the info axis to set of items or wildcard
 |      
 |      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 None
 |          The axis to filter on. By default this is the info axis. The "info
 |          axis" is the axis that is used when indexing with ``[]``. For
 |          example, ``df = DataFrame({'a': [1, 2, 3, 4]]}); df['a']``. So,
 |          the ``DataFrame`` columns are the info axis.
 |      
 |      Notes
 |      -----
 |      Arguments are mutually exclusive, but this is not checked for
 |  
 |  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.
 |  
 |  get_values(self)
 |      same as values (but handles sparseness conversions)
 |  
 |  groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False)
 |      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 / list of functions, dict, Series, or tuple /
 |          list of column names.
 |          Called on each element of the object index to determine the groups.
 |          If a dict or Series is passed, the Series or dict VALUES will be
 |          used to determine the groups
 |      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', 'pchip'}
 |      
 |          * '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', and 'pchip' are all
 |            wrappers around the scipy interpolation methods of similar
 |            names. These use the actual numerical values of the index. See
 |            the scipy documentation for more on their behavior
 |            `here <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__  # noqa
 |            `and here <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__  # noqa
 |      
 |      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.
 |      limit_direction : {'forward', 'backward', 'both'}, defaults to '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
 |  
 |  iterkv(self, *args, **kwargs)
 |      iteritems alias used to get around 2to3. Deprecated
 |  
 |  keys(self)
 |      Get the 'info axis' (see Indexing for more)
 |      
 |      This is index for Series, columns for DataFrame and major_axis for
 |      Panel.
 |  
 |  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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  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 scaler 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)
 |      Convenience method for frequency conversion and resampling of regular
 |      time-series data.
 |      
 |      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
 |      
 |      
 |      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
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00     1
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00     2
 |      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
 |  
 |  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)
 |      Squeeze length 1 dimensions.
 |  
 |  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
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=True)
 |      Analogous to ndarray.take
 |      
 |      Parameters
 |      ----------
 |      indices : list / array of ints
 |      axis : int, default 0
 |      convert : translate neg to pos indices (default)
 |      is_copy : mark the returned frame as a copy
 |      
 |      Returns
 |      -------
 |      taken : type of caller
 |  
 |  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)
 |      Activate the HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          indentifier for the group in the store
 |      mode : optional, {'a', 'w', 'r', 'r+'}, default 'a'
 |      
 |        ``'r'``
 |            Read-only; no data can be modified.
 |        ``'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
 |      complevel : int, 1-9, default 0
 |          If a complib is specified compression will be applied
 |          where possible
 |      complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
 |          If complevel is > 0 apply compression to objects written
 |          in the store wherever possible
 |      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='epoch', double_precision=10, force_ascii=True, date_unit='ms', default_handler=None)
 |      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
 |      
 |      date_format : {'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso`` = ISO8601, 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.
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |  
 |  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)
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |  
 |  to_sql(self, name, con, flavor='sqlite', 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', 'mysql'}, default 'sqlite'
 |          The flavor of SQL to use. Ignored when using SQLAlchemy engine.
 |          'mysql' is deprecated and will be removed in future versions, but
 |          it will be further supported through SQLAlchemy engines.
 |      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
 |      dates.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before date
 |      after : date
 |          Truncate after date
 |      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 datetools 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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  xs(self, key, axis=0, level=None, copy=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.
 |      copy : boolean [deprecated]
 |          Whether to make a copy of the data
 |      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()
 |  
 |  dtypes
 |      Return the dtypes in this object.
 |  
 |  empty
 |      True if NDFrame is entirely empty [no items], meaning any of the
 |      axes are of length 0.
 |      
 |      Notes
 |      -----
 |      If NDFrame contains only NaNs, it is still not considered empty. See
 |      the example below.
 |      
 |      Examples
 |      --------
 |      An example of an actual empty DataFrame. Notice the index is empty:
 |      
 |      >>> df_empty = pd.DataFrame({'A' : []})
 |      >>> df_empty
 |      Empty DataFrame
 |      Columns: [A]
 |      Index: []
 |      >>> df_empty.empty
 |      True
 |      
 |      If we only have NaNs in our DataFrame, it is not considered empty! We
 |      will need to drop the NaNs to make the DataFrame empty:
 |      
 |      >>> df = pd.DataFrame({'A' : [np.nan]})
 |      >>> df
 |          A
 |      0 NaN
 |      >>> df.empty
 |      False
 |      >>> df.dropna().empty
 |      True
 |      
 |      See also
 |      --------
 |      pandas.Series.dropna
 |      pandas.DataFrame.dropna
 |  
 |  ftypes
 |      Return the ftypes (indication of sparse/dense and dtype)
 |      in this object.
 |  
 |  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.
 |      
 |      ``.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.
 |      
 |      ``.loc`` will raise a ``KeyError`` when the items are not found.
 |      
 |      See more at :ref:`Selection by Label <indexing.label>`
 |  
 |  ndim
 |      Number of axes / array dimensions
 |  
 |  size
 |      number of elements in the NDFrame
 |  
 |  values
 |      Numpy representation of NDFrame
 |      
 |      Notes
 |      -----
 |      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.
 |  
 |  ----------------------------------------------------------------------
 |  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.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pandas.core.base.StringMixin:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

In [55]:

    

help(frame)


    

    




Help on DataFrame in module pandas.core.frame object:

class DataFrame(pandas.core.generic.NDFrame)
 |  Two-dimensional size-mutable, potentially heterogeneous tabular data
 |  structure with labeled axes (rows and columns). Arithmetic operations
 |  align on both row and column labels. Can be thought of as a dict-like
 |  container for Series objects. The primary pandas data structure
 |  
 |  Parameters
 |  ----------
 |  data : numpy ndarray (structured or homogeneous), dict, or DataFrame
 |      Dict can contain Series, arrays, constants, or list-like objects
 |  index : Index or array-like
 |      Index to use for resulting frame. Will default to np.arange(n) if
 |      no indexing information part of input data and no index provided
 |  columns : Index or array-like
 |      Column labels to use for resulting frame. Will default to
 |      np.arange(n) if no column labels are provided
 |  dtype : dtype, default None
 |      Data type to force, otherwise infer
 |  copy : boolean, default False
 |      Copy data from inputs. Only affects DataFrame / 2d ndarray input
 |  
 |  Examples
 |  --------
 |  >>> d = {'col1': ts1, 'col2': ts2}
 |  >>> df = DataFrame(data=d, index=index)
 |  >>> df2 = DataFrame(np.random.randn(10, 5))
 |  >>> df3 = DataFrame(np.random.randn(10, 5),
 |  ...                 columns=['a', 'b', 'c', 'd', 'e'])
 |  
 |  See also
 |  --------
 |  DataFrame.from_records : constructor from tuples, also record arrays
 |  DataFrame.from_dict : from dicts of Series, arrays, or dicts
 |  DataFrame.from_items : from sequence of (key, value) pairs
 |  pandas.read_csv, pandas.read_table, pandas.read_clipboard
 |  
 |  Method resolution order:
 |      DataFrame
 |      pandas.core.generic.NDFrame
 |      pandas.core.base.PandasObject
 |      pandas.core.base.StringMixin
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __add__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __and__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __and__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __div__ = __truediv__(self, other, axis=None, level=None, fill_value=None)
 |  
 |  __eq__(self, other)
 |      Wrapper for comparison method __eq__
 |  
 |  __floordiv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __floordiv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ge__(self, other)
 |      Wrapper for comparison method __ge__
 |  
 |  __getitem__(self, key)
 |  
 |  __gt__(self, other)
 |      Wrapper for comparison method __gt__
 |  
 |  __iadd__ = f(self, other)
 |  
 |  __imul__ = f(self, other)
 |  
 |  __init__(self, data=None, index=None, columns=None, dtype=None, copy=False)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __ipow__ = f(self, other)
 |  
 |  __isub__ = f(self, other)
 |  
 |  __itruediv__ = f(self, other)
 |  
 |  __le__(self, other)
 |      Wrapper for comparison method __le__
 |  
 |  __len__(self)
 |      Returns length of info axis, but here we use the index
 |  
 |  __lt__(self, other)
 |      Wrapper for comparison method __lt__
 |  
 |  __mod__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __mod__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __mul__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __mul__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ne__(self, other)
 |      Wrapper for comparison method __ne__
 |  
 |  __or__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __or__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __pow__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __pow__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __radd__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __radd__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rand__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __rand__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rdiv__ = __rtruediv__(self, other, axis=None, level=None, fill_value=None)
 |  
 |  __rfloordiv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rfloordiv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rmod__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rmod__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rmul__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rmul__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __ror__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __ror__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rpow__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rpow__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rsub__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rsub__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rtruediv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __rtruediv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __rxor__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __rxor__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __sub__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __truediv__(self, other, axis=None, level=None, fill_value=None)
 |      Binary operator __truediv__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  __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__(self, other, axis='columns', level=None, fill_value=None)
 |      Binary operator __xor__ with support to substitute a fill_value for missing data in
 |      one of the inputs
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame locations are
 |          missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  add(self, other, axis='columns', level=None, fill_value=None)
 |      Addition of dataframe and other, element-wise (binary operator `add`).
 |      
 |      Equivalent to ``dataframe + other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.radd
 |  
 |  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, 1, 'index', 'columns'}, default 0
 |          Filling axis, method and limit
 |      broadcast_axis : {0, 1, 'index', 'columns'}, default None
 |          Broadcast values along this axis, if aligning two objects of
 |          different dimensions
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Returns
 |      -------
 |      (left, right) : (DataFrame, 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), columns (1)}
 |      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 Series
 |      bool_only : boolean, default None
 |          Include only boolean data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      all : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      bool_only : boolean, default None
 |          Include only boolean data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      any : Series or DataFrame (if level specified)
 |  
 |  append(self, other, ignore_index=False, verify_integrity=False)
 |      Append rows of `other` to the end of this frame, returning a new
 |      object. Columns not in this frame are added as new columns.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame or Series/dict-like object, or list of these
 |          The data to append.
 |      ignore_index : boolean, default False
 |          If True, do not use the index labels.
 |      verify_integrity : boolean, default False
 |          If True, raise ValueError on creating index with duplicates.
 |      
 |      Returns
 |      -------
 |      appended : DataFrame
 |      
 |      Notes
 |      -----
 |      If a list of dict/series is passed and the keys are all contained in
 |      the DataFrame's index, the order of the columns in the resulting
 |      DataFrame will be unchanged.
 |      
 |      See also
 |      --------
 |      pandas.concat : General function to concatenate DataFrame, Series
 |          or Panel objects
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame([[1, 2], [3, 4]], columns=list('AB'))
 |      >>> df
 |         A  B
 |      0  1  2
 |      1  3  4
 |      >>> df2 = pd.DataFrame([[5, 6], [7, 8]], columns=list('AB'))
 |      >>> df.append(df2)
 |         A  B
 |      0  1  2
 |      1  3  4
 |      0  5  6
 |      1  7  8
 |      
 |      With `ignore_index` set to True:
 |      
 |      >>> df.append(df2, ignore_index=True)
 |         A  B
 |      0  1  2
 |      1  3  4
 |      2  5  6
 |      3  7  8
 |  
 |  apply(self, func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
 |      Applies function along input axis of DataFrame.
 |      
 |      Objects passed to functions are Series objects having index
 |      either the DataFrame's index (axis=0) or the columns (axis=1).
 |      Return type depends on whether passed function aggregates, or the
 |      reduce argument if the DataFrame is empty.
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Function to apply to each column/row
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          * 0 or 'index': apply function to each column
 |          * 1 or 'columns': apply function to each row
 |      broadcast : boolean, default False
 |          For aggregation functions, return object of same size with values
 |          propagated
 |      raw : boolean, default False
 |          If False, convert each row or column into a Series. If raw=True the
 |          passed function will receive ndarray objects instead. If you are
 |          just applying a NumPy reduction function this will achieve much
 |          better performance
 |      reduce : boolean or None, default None
 |          Try to apply reduction procedures. If the DataFrame is empty,
 |          apply will use reduce to determine whether the result should be a
 |          Series or a DataFrame. If reduce is None (the default), apply's
 |          return value will be guessed by calling func an empty Series (note:
 |          while guessing, exceptions raised by func will be ignored). If
 |          reduce is True a Series will always be returned, and if False a
 |          DataFrame will always be returned.
 |      args : tuple
 |          Positional arguments to pass to function in addition to the
 |          array/series
 |      Additional keyword arguments will be passed as keywords to the function
 |      
 |      Notes
 |      -----
 |      In the current implementation apply calls func twice on the
 |      first column/row to decide whether it can take a fast or slow
 |      code path. This can lead to unexpected behavior if func has
 |      side-effects, as they will take effect twice for the first
 |      column/row.
 |      
 |      Examples
 |      --------
 |      >>> df.apply(numpy.sqrt) # returns DataFrame
 |      >>> df.apply(numpy.sum, axis=0) # equiv to df.sum(0)
 |      >>> df.apply(numpy.sum, axis=1) # equiv to df.sum(1)
 |      
 |      See also
 |      --------
 |      DataFrame.applymap: For elementwise operations
 |      
 |      Returns
 |      -------
 |      applied : Series or DataFrame
 |  
 |  applymap(self, func)
 |      Apply a function to a DataFrame that is intended to operate
 |      elementwise, i.e. like doing map(func, series) for each series in the
 |      DataFrame
 |      
 |      Parameters
 |      ----------
 |      func : function
 |          Python function, returns a single value from a single value
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame(np.random.randn(3, 3))
 |      >>> df
 |          0         1          2
 |      0  -0.029638  1.081563   1.280300
 |      1   0.647747  0.831136  -1.549481
 |      2   0.513416 -0.884417   0.195343
 |      >>> df = df.applymap(lambda x: '%.2f' % x)
 |      >>> df
 |          0         1          2
 |      0  -0.03      1.08       1.28
 |      1   0.65      0.83      -1.55
 |      2   0.51     -0.88       0.20
 |      
 |      Returns
 |      -------
 |      applied : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.apply : For operations on rows/columns
 |  
 |  assign(self, **kwargs)
 |      Assign new columns to a DataFrame, returning a new object
 |      (a copy) with all the original columns in addition to the new ones.
 |      
 |      .. versionadded:: 0.16.0
 |      
 |      Parameters
 |      ----------
 |      kwargs : keyword, value pairs
 |          keywords are the column names. If the values are
 |          callable, they are computed on the DataFrame and
 |          assigned to the new columns. If the values are
 |          not callable, (e.g. a Series, scalar, or array),
 |          they are simply assigned.
 |      
 |      Returns
 |      -------
 |      df : DataFrame
 |          A new DataFrame with the new columns in addition to
 |          all the existing columns.
 |      
 |      Notes
 |      -----
 |      Since ``kwargs`` is a dictionary, the order of your
 |      arguments may not be preserved. The make things predicatable,
 |      the columns are inserted in alphabetical order, at the end of
 |      your DataFrame. Assigning multiple columns within the same
 |      ``assign`` is possible, but you cannot reference other columns
 |      created within the same ``assign`` call.
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'A': range(1, 11), 'B': np.random.randn(10)})
 |      
 |      Where the value is a callable, evaluated on `df`:
 |      
 |      >>> df.assign(ln_A = lambda x: np.log(x.A))
 |          A         B      ln_A
 |      0   1  0.426905  0.000000
 |      1   2 -0.780949  0.693147
 |      2   3 -0.418711  1.098612
 |      3   4 -0.269708  1.386294
 |      4   5 -0.274002  1.609438
 |      5   6 -0.500792  1.791759
 |      6   7  1.649697  1.945910
 |      7   8 -1.495604  2.079442
 |      8   9  0.549296  2.197225
 |      9  10 -0.758542  2.302585
 |      
 |      Where the value already exists and is inserted:
 |      
 |      >>> newcol = np.log(df['A'])
 |      >>> df.assign(ln_A=newcol)
 |          A         B      ln_A
 |      0   1  0.426905  0.000000
 |      1   2 -0.780949  0.693147
 |      2   3 -0.418711  1.098612
 |      3   4 -0.269708  1.386294
 |      4   5 -0.274002  1.609438
 |      5   6 -0.500792  1.791759
 |      6   7  1.649697  1.945910
 |      7   8 -1.495604  2.079442
 |      8   9  0.549296  2.197225
 |      9  10 -0.758542  2.302585
 |  
 |  boxplot(self, column=None, by=None, ax=None, fontsize=None, rot=0, grid=True, figsize=None, layout=None, return_type=None, **kwds)
 |      Make a box plot from DataFrame column optionally grouped by some columns or
 |      other inputs
 |      
 |      Parameters
 |      ----------
 |      data : the pandas object holding the data
 |      column : column name or list of names, or vector
 |          Can be any valid input to groupby
 |      by : string or sequence
 |          Column in the DataFrame to group by
 |      ax : Matplotlib axes object, optional
 |      fontsize : int or string
 |      rot : label rotation angle
 |      figsize : A tuple (width, height) in inches
 |      grid : Setting this to True will show the grid
 |      layout : tuple (optional)
 |          (rows, columns) for the layout of the plot
 |      return_type : {'axes', 'dict', 'both'}, default 'dict'
 |          The kind of object to return. 'dict' returns a dictionary
 |          whose values are the matplotlib Lines of the boxplot;
 |          'axes' returns the matplotlib axes the boxplot is drawn on;
 |          'both' returns a namedtuple with the axes and dict.
 |      
 |          When grouping with ``by``, a dict mapping columns to ``return_type``
 |          is returned.
 |      
 |      kwds : other plotting keyword arguments to be passed to matplotlib boxplot
 |             function
 |      
 |      Returns
 |      -------
 |      lines : dict
 |      ax : matplotlib Axes
 |      (ax, lines): namedtuple
 |      
 |      Notes
 |      -----
 |      Use ``return_type='dict'`` when you want to tweak the appearance
 |      of the lines after plotting. In this case a dict containing the Lines
 |      making up the boxes, caps, fliers, medians, and whiskers is returned.
 |  
 |  combine(self, other, func, fill_value=None, overwrite=True)
 |      Add two DataFrame objects and do not propagate NaN values, so if for a
 |      (column, time) one frame is missing a value, it will default to the
 |      other frame's value (which might be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      func : function
 |      fill_value : scalar value
 |      overwrite : boolean, default True
 |          If True then overwrite values for common keys in the calling frame
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |  
 |  combineAdd(self, other)
 |      DEPRECATED. Use ``DataFrame.add(other, fill_value=0.)`` instead.
 |      
 |      Add two DataFrame objects and do not propagate
 |      NaN values, so if for a (column, time) one frame is missing a
 |      value, it will default to the other frame's value (which might
 |      be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.add
 |  
 |  combineMult(self, other)
 |      DEPRECATED. Use ``DataFrame.mul(other, fill_value=1.)`` instead.
 |      
 |      Multiply two DataFrame objects and do not propagate NaN values, so if
 |      for a (column, time) one frame is missing a value, it will default to
 |      the other frame's value (which might be NaN as well)
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mul
 |  
 |  combine_first(self, other)
 |      Combine two DataFrame objects and default to non-null values in frame
 |      calling the method. Result index columns will be the union of the
 |      respective indexes and columns
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      
 |      Examples
 |      --------
 |      a's values prioritized, use values from b to fill holes:
 |      
 |      >>> a.combine_first(b)
 |      
 |      
 |      Returns
 |      -------
 |      combined : DataFrame
 |  
 |  compound(self, axis=None, skipna=None, level=None)
 |      Return the compound percentage of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      compounded : Series or DataFrame (if level specified)
 |  
 |  corr(self, method='pearson', min_periods=1)
 |      Compute pairwise correlation of columns, excluding NA/null values
 |      
 |      Parameters
 |      ----------
 |      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 required per pair of columns
 |          to have a valid result. Currently only available for pearson
 |          and spearman correlation
 |      
 |      Returns
 |      -------
 |      y : DataFrame
 |  
 |  corrwith(self, other, axis=0, drop=False)
 |      Compute pairwise correlation between rows or columns of two DataFrame
 |      objects.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' to compute column-wise, 1 or 'columns' for row-wise
 |      drop : boolean, default False
 |          Drop missing indices from result, default returns union of all
 |      
 |      Returns
 |      -------
 |      correls : Series
 |  
 |  count(self, axis=0, level=None, numeric_only=False)
 |      Return Series with number of non-NA/null observations over requested
 |      axis. Works with non-floating point data as well (detects NaN and None)
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      level : int or level name, default None
 |          If the axis is a MultiIndex (hierarchical), count along a
 |          particular level, collapsing into a DataFrame
 |      numeric_only : boolean, default False
 |          Include only float, int, boolean data
 |      
 |      Returns
 |      -------
 |      count : Series (or DataFrame if level specified)
 |  
 |  cov(self, min_periods=None)
 |      Compute pairwise covariance of columns, excluding NA/null values
 |      
 |      Parameters
 |      ----------
 |      min_periods : int, optional
 |          Minimum number of observations required per pair of columns
 |          to have a valid result.
 |      
 |      Returns
 |      -------
 |      y : DataFrame
 |      
 |      Notes
 |      -----
 |      `y` contains the covariance matrix of the DataFrame's time series.
 |      The covariance is normalized by N-1 (unbiased estimator).
 |  
 |  cummax = max(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative max over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      max : Series
 |  
 |  cummin = min(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative min over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      min : Series
 |  
 |  cumprod = prod(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative prod over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      prod : Series
 |  
 |  cumsum = sum(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative sum over requested axis.
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      sum : Series
 |  
 |  diff(self, periods=1, axis=0)
 |      1st discrete difference of object
 |      
 |      Parameters
 |      ----------
 |      periods : int, default 1
 |          Periods to shift for forming difference
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          Take difference over rows (0) or columns (1).
 |      
 |          .. versionadded: 0.16.1
 |      
 |      Returns
 |      -------
 |      diffed : DataFrame
 |  
 |  div = truediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  divide = truediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  dot(self, other)
 |      Matrix multiplication with DataFrame or Series objects
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame or Series
 |      
 |      Returns
 |      -------
 |      dot_product : DataFrame or Series
 |  
 |  drop_duplicates(self, subset=None, keep='first', inplace=False)
 |      Return DataFrame with duplicate rows removed, optionally only
 |      considering certain columns
 |      
 |      Parameters
 |      ----------
 |      subset : column label or sequence of labels, optional
 |          Only consider certain columns for identifying duplicates, by
 |          default use all of the columns
 |      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.
 |      take_last : deprecated
 |      inplace : boolean, default False
 |          Whether to drop duplicates in place or to return a copy
 |      
 |      Returns
 |      -------
 |      deduplicated : DataFrame
 |  
 |  dropna(self, axis=0, how='any', thresh=None, subset=None, inplace=False)
 |      Return object with labels on given axis omitted where alternately any
 |      or all of the data are missing
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, or tuple/list thereof
 |          Pass tuple or list to drop on multiple axes
 |      how : {'any', 'all'}
 |          * any : if any NA values are present, drop that label
 |          * all : if all values are NA, drop that label
 |      thresh : int, default None
 |          int value : require that many non-NA values
 |      subset : array-like
 |          Labels along other axis to consider, e.g. if you are dropping rows
 |          these would be a list of columns to include
 |      inplace : boolean, default False
 |          If True, do operation inplace and return None.
 |      
 |      Returns
 |      -------
 |      dropped : DataFrame
 |  
 |  duplicated(self, subset=None, keep='first')
 |      Return boolean Series denoting duplicate rows, optionally only
 |      considering certain columns
 |      
 |      Parameters
 |      ----------
 |      subset : column label or sequence of labels, optional
 |          Only consider certain columns for identifying duplicates, by
 |          default use all of the columns
 |      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``.
 |      take_last : deprecated
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods eq
 |  
 |  eval(self, expr, inplace=None, **kwargs)
 |      Evaluate an expression in the context of the calling DataFrame
 |      instance.
 |      
 |      Parameters
 |      ----------
 |      expr : string
 |          The expression string to evaluate.
 |      inplace : bool
 |          If the expression contains an assignment, whether to return a new
 |          DataFrame or mutate the existing.
 |      
 |          WARNING: inplace=None currently falls back to to True, but
 |          in a future version, will default to False.  Use inplace=True
 |          explicitly rather than relying on the default.
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      kwargs : dict
 |          See the documentation for :func:`~pandas.eval` for complete details
 |          on the keyword arguments accepted by
 |          :meth:`~pandas.DataFrame.query`.
 |      
 |      Returns
 |      -------
 |      ret : ndarray, scalar, or pandas object
 |      
 |      See Also
 |      --------
 |      pandas.DataFrame.query
 |      pandas.DataFrame.assign
 |      pandas.eval
 |      
 |      Notes
 |      -----
 |      For more details see the API documentation for :func:`~pandas.eval`.
 |      For detailed examples see :ref:`enhancing performance with eval
 |      <enhancingperf.eval>`.
 |      
 |      Examples
 |      --------
 |      >>> from numpy.random import randn
 |      >>> from pandas import DataFrame
 |      >>> df = DataFrame(randn(10, 2), columns=list('ab'))
 |      >>> df.eval('a + b')
 |      >>> df.eval('c = a + b')
 |  
 |  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
 |      
 |      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, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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, 1, 'index', 'columns'}
 |      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.
 |      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 : DataFrame
 |  
 |  first_valid_index(self)
 |      Return label for first non-NA/null value
 |  
 |  floordiv(self, other, axis='columns', level=None, fill_value=None)
 |      Integer division of dataframe and other, element-wise (binary operator `floordiv`).
 |      
 |      Equivalent to ``dataframe // other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rfloordiv
 |  
 |  ge(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods ge
 |  
 |  get_value(self, index, col, takeable=False)
 |      Quickly retrieve single value at passed column and index
 |      
 |      Parameters
 |      ----------
 |      index : row label
 |      col : column label
 |      takeable : interpret the index/col as indexers, default False
 |      
 |      Returns
 |      -------
 |      value : scalar value
 |  
 |  gt(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods gt
 |  
 |  hist = hist_frame(data, column=None, by=None, grid=True, xlabelsize=None, xrot=None, ylabelsize=None, yrot=None, ax=None, sharex=False, sharey=False, figsize=None, layout=None, bins=10, **kwds)
 |      Draw histogram of the DataFrame's series using matplotlib / pylab.
 |      
 |      Parameters
 |      ----------
 |      data : DataFrame
 |      column : string or sequence
 |          If passed, will be used to limit data to a subset of columns
 |      by : object, optional
 |          If passed, then used to form histograms for separate groups
 |      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
 |      ax : matplotlib axes object, default None
 |      sharex : boolean, default True if ax is None else False
 |          In case subplots=True, share x axis and set some x axis labels to
 |          invisible; defaults to True if ax is None otherwise False if an ax
 |          is passed in; Be aware, that passing in both an ax and sharex=True
 |          will alter all x axis labels for all subplots in a figure!
 |      sharey : boolean, default False
 |          In case subplots=True, share y axis and set some y axis labels to
 |          invisible
 |      figsize : tuple
 |          The size of the figure to create in inches by default
 |      layout: (optional) a tuple (rows, columns) for the layout of the histograms
 |      bins: integer, default 10
 |          Number of histogram bins to be used
 |      kwds : other plotting keyword arguments
 |          To be passed to hist function
 |  
 |  icol(self, i)
 |      DEPRECATED. Use ``.iloc[:, i]`` instead
 |  
 |  idxmax(self, axis=0, skipna=True)
 |      Return index of first occurrence of maximum over requested axis.
 |      NA/null values are excluded.
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be first index.
 |      
 |      Returns
 |      -------
 |      idxmax : Series
 |      
 |      Notes
 |      -----
 |      This method is the DataFrame version of ``ndarray.argmax``.
 |      
 |      See Also
 |      --------
 |      Series.idxmax
 |  
 |  idxmin(self, axis=0, skipna=True)
 |      Return index of first occurrence of minimum over requested axis.
 |      NA/null values are excluded.
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      skipna : boolean, default True
 |          Exclude NA/null values. If an entire row/column is NA, the result
 |          will be NA
 |      
 |      Returns
 |      -------
 |      idxmin : Series
 |      
 |      Notes
 |      -----
 |      This method is the DataFrame version of ``ndarray.argmin``.
 |      
 |      See Also
 |      --------
 |      Series.idxmin
 |  
 |  iget_value(self, i, j)
 |      DEPRECATED. Use ``.iat[i, j]`` instead
 |  
 |  info(self, verbose=None, buf=None, max_cols=None, memory_usage=None, null_counts=None)
 |      Concise summary of a DataFrame.
 |      
 |      Parameters
 |      ----------
 |      verbose : {None, True, False}, optional
 |          Whether to print the full summary.
 |          None follows the `display.max_info_columns` setting.
 |          True or False overrides the `display.max_info_columns` setting.
 |      buf : writable buffer, defaults to sys.stdout
 |      max_cols : int, default None
 |          Determines whether full summary or short summary is printed.
 |          None follows the `display.max_info_columns` setting.
 |      memory_usage : boolean/string, default None
 |          Specifies whether total memory usage of the DataFrame
 |          elements (including index) should be displayed. None follows
 |          the `display.memory_usage` setting. True or False overrides
 |          the `display.memory_usage` setting. A value of 'deep' is equivalent
 |          of True, with deep introspection. Memory usage is shown in
 |          human-readable units (base-2 representation).
 |      null_counts : boolean, default None
 |          Whether to show the non-null counts
 |      
 |          - If None, then only show if the frame is smaller than
 |            max_info_rows and max_info_columns.
 |          - If True, always show counts.
 |          - If False, never show counts.
 |  
 |  insert(self, loc, column, value, allow_duplicates=False)
 |      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 : int, Series, or array-like
 |  
 |  irow(self, i, copy=False)
 |      DEPRECATED. Use ``.iloc[i]`` instead
 |  
 |  isin(self, values)
 |      Return boolean DataFrame showing whether each element in the
 |      DataFrame is contained in values.
 |      
 |      Parameters
 |      ----------
 |      values : iterable, Series, DataFrame or dictionary
 |          The result will only be true at a location if all the
 |          labels match. If `values` is a Series, that's the index. If
 |          `values` is a dictionary, the keys must be the column names,
 |          which must match. If `values` is a DataFrame,
 |          then both the index and column labels must match.
 |      
 |      Returns
 |      -------
 |      
 |      DataFrame of booleans
 |      
 |      Examples
 |      --------
 |      When ``values`` is a list:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': ['a', 'b', 'f']})
 |      >>> df.isin([1, 3, 12, 'a'])
 |             A      B
 |      0   True   True
 |      1  False  False
 |      2   True  False
 |      
 |      When ``values`` is a dict:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': [1, 4, 7]})
 |      >>> df.isin({'A': [1, 3], 'B': [4, 7, 12]})
 |             A      B
 |      0   True  False  # Note that B didn't match the 1 here.
 |      1  False   True
 |      2   True   True
 |      
 |      When ``values`` is a Series or DataFrame:
 |      
 |      >>> df = DataFrame({'A': [1, 2, 3], 'B': ['a', 'b', 'f']})
 |      >>> other = DataFrame({'A': [1, 3, 3, 2], 'B': ['e', 'f', 'f', 'e']})
 |      >>> df.isin(other)
 |             A      B
 |      0   True  False
 |      1  False  False  # Column A in `other` has a 3, but not at index 1.
 |      2   True   True
 |  
 |  items = iteritems(self)
 |  
 |  iteritems(self)
 |      Iterator over (column name, Series) pairs.
 |      
 |      See also
 |      --------
 |      iterrows : Iterate over DataFrame rows as (index, Series) pairs.
 |      itertuples : Iterate over DataFrame rows as namedtuples of the values.
 |  
 |  iterrows(self)
 |      Iterate over DataFrame rows as (index, Series) pairs.
 |      
 |      Notes
 |      -----
 |      
 |      1. Because ``iterrows`` returns a Series for each row,
 |         it does **not** preserve dtypes across the rows (dtypes are
 |         preserved across columns for DataFrames). For example,
 |      
 |         >>> df = pd.DataFrame([[1, 1.5]], columns=['int', 'float'])
 |         >>> row = next(df.iterrows())[1]
 |         >>> row
 |         int      1.0
 |         float    1.5
 |         Name: 0, dtype: float64
 |         >>> print(row['int'].dtype)
 |         float64
 |         >>> print(df['int'].dtype)
 |         int64
 |      
 |         To preserve dtypes while iterating over the rows, it is better
 |         to use :meth:`itertuples` which returns namedtuples of the values
 |         and which is generally faster than ``iterrows``.
 |      
 |      2. You should **never modify** something you are iterating over.
 |         This is not guaranteed to work in all cases. Depending on the
 |         data types, the iterator returns a copy and not a view, and writing
 |         to it will have no effect.
 |      
 |      Returns
 |      -------
 |      it : generator
 |          A generator that iterates over the rows of the frame.
 |      
 |      See also
 |      --------
 |      itertuples : Iterate over DataFrame rows as namedtuples of the values.
 |      iteritems : Iterate over (column name, Series) pairs.
 |  
 |  itertuples(self, index=True, name='Pandas')
 |      Iterate over DataFrame rows as namedtuples, with index value as first
 |      element of the tuple.
 |      
 |      Parameters
 |      ----------
 |      index : boolean, default True
 |          If True, return the index as the first element of the tuple.
 |      name : string, default "Pandas"
 |          The name of the returned namedtuples or None to return regular
 |          tuples.
 |      
 |      Notes
 |      -----
 |      The column names will be renamed to positional names if they are
 |      invalid Python identifiers, repeated, or start with an underscore.
 |      With a large number of columns (>255), regular tuples are returned.
 |      
 |      See also
 |      --------
 |      iterrows : Iterate over DataFrame rows as (index, Series) pairs.
 |      iteritems : Iterate over (column name, Series) pairs.
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = pd.DataFrame({'col1': [1, 2], 'col2': [0.1, 0.2]},
 |                            index=['a', 'b'])
 |      >>> df
 |         col1  col2
 |      a     1   0.1
 |      b     2   0.2
 |      >>> for row in df.itertuples():
 |      ...     print(row)
 |      ...
 |      Pandas(Index='a', col1=1, col2=0.10000000000000001)
 |      Pandas(Index='b', col1=2, col2=0.20000000000000001)
 |  
 |  join(self, other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
 |      Join columns with other DataFrame either on index or on a key
 |      column. Efficiently Join multiple DataFrame objects by index at once by
 |      passing a list.
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame, Series with name field set, or list of DataFrame
 |          Index should be similar to one of the columns in this one. If a
 |          Series is passed, its name attribute must be set, and that will be
 |          used as the column name in the resulting joined DataFrame
 |      on : column name, tuple/list of column names, or array-like
 |          Column(s) to use for joining, otherwise join on index. If multiples
 |          columns given, the passed DataFrame must have a MultiIndex. Can
 |          pass an array as the join key if not already contained in the
 |          calling DataFrame. Like an Excel VLOOKUP operation
 |      how : {'left', 'right', 'outer', 'inner'}
 |          How to handle indexes of the two objects. Default: 'left'
 |          for joining on index, None otherwise
 |      
 |          * left: use calling frame's index
 |          * right: use input frame's index
 |          * outer: form union of indexes
 |          * inner: use intersection of indexes
 |      lsuffix : string
 |          Suffix to use from left frame's overlapping columns
 |      rsuffix : string
 |          Suffix to use from right frame's overlapping columns
 |      sort : boolean, default False
 |          Order result DataFrame lexicographically by the join key. If False,
 |          preserves the index order of the calling (left) DataFrame
 |      
 |      Notes
 |      -----
 |      on, lsuffix, and rsuffix options are not supported when passing a list
 |      of DataFrame objects
 |      
 |      Returns
 |      -------
 |      joined : DataFrame
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      kurt : Series or DataFrame (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, axis='columns', level=None)
 |      Wrapper for flexible comparison methods le
 |  
 |  lookup(self, row_labels, col_labels)
 |      Label-based "fancy indexing" function for DataFrame.
 |      Given equal-length arrays of row and column labels, return an
 |      array of the values corresponding to each (row, col) pair.
 |      
 |      Parameters
 |      ----------
 |      row_labels : sequence
 |          The row labels to use for lookup
 |      col_labels : sequence
 |          The column labels to use for lookup
 |      
 |      Notes
 |      -----
 |      Akin to::
 |      
 |          result = []
 |          for row, col in zip(row_labels, col_labels):
 |              result.append(df.get_value(row, col))
 |      
 |      Examples
 |      --------
 |      values : ndarray
 |          The found values
 |  
 |  lt(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods lt
 |  
 |  mad(self, axis=None, skipna=None, level=None)
 |      Return the mean absolute deviation of the values for the requested axis
 |      
 |      Parameters
 |      ----------
 |      axis : {index (0), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      mad : Series or DataFrame (if level specified)
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      max : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      mean : Series or DataFrame (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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      median : Series or DataFrame (if level specified)
 |  
 |  memory_usage(self, index=True, deep=False)
 |      Memory usage of DataFrame columns.
 |      
 |      Parameters
 |      ----------
 |      index : bool
 |          Specifies whether to include memory usage of DataFrame's
 |          index in returned Series. If `index=True` (default is False)
 |          the first index of the Series is `Index`.
 |      deep : bool
 |          Introspect the data deeply, interrogate
 |          `object` dtypes for system-level memory consumption
 |      
 |      Returns
 |      -------
 |      sizes : Series
 |          A series with column names as index and memory usage of
 |          columns with units of bytes.
 |      
 |      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
 |  
 |  merge(self, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False)
 |      Merge DataFrame objects by performing a database-style join operation by
 |      columns or indexes.
 |      
 |      If joining columns on columns, the DataFrame indexes *will be
 |      ignored*. Otherwise if joining indexes on indexes or indexes on a column or
 |      columns, the index will be passed on.
 |      
 |      Parameters
 |      ----------
 |      right : DataFrame
 |      how : {'left', 'right', 'outer', 'inner'}, default 'inner'
 |          * left: use only keys from left frame (SQL: left outer join)
 |          * right: use only keys from right frame (SQL: right outer join)
 |          * outer: use union of keys from both frames (SQL: full outer join)
 |          * inner: use intersection of keys from both frames (SQL: inner join)
 |      on : label or list
 |          Field names to join on. Must be found in both DataFrames. If on is
 |          None and not merging on indexes, then it merges on the intersection of
 |          the columns by default.
 |      left_on : label or list, or array-like
 |          Field names to join on in left DataFrame. Can be a vector or list of
 |          vectors of the length of the DataFrame to use a particular vector as
 |          the join key instead of columns
 |      right_on : label or list, or array-like
 |          Field names to join on in right DataFrame or vector/list of vectors per
 |          left_on docs
 |      left_index : boolean, default False
 |          Use the index from the left DataFrame as the join key(s). If it is a
 |          MultiIndex, the number of keys in the other DataFrame (either the index
 |          or a number of columns) must match the number of levels
 |      right_index : boolean, default False
 |          Use the index from the right DataFrame as the join key. Same caveats as
 |          left_index
 |      sort : boolean, default False
 |          Sort the join keys lexicographically in the result DataFrame
 |      suffixes : 2-length sequence (tuple, list, ...)
 |          Suffix to apply to overlapping column names in the left and right
 |          side, respectively
 |      copy : boolean, default True
 |          If False, do not copy data unnecessarily
 |      indicator : boolean or string, default False
 |          If True, adds a column to output DataFrame called "_merge" with
 |          information on the source of each row.
 |          If string, column with information on source of each row will be added to
 |          output DataFrame, and column will be named value of string.
 |          Information column is Categorical-type and takes on a value of "left_only"
 |          for observations whose merge key only appears in 'left' DataFrame,
 |          "right_only" for observations whose merge key only appears in 'right'
 |          DataFrame, and "both" if the observation's merge key is found in both.
 |      
 |          .. versionadded:: 0.17.0
 |      
 |      Examples
 |      --------
 |      
 |      >>> A              >>> B
 |          lkey value         rkey value
 |      0   foo  1         0   foo  5
 |      1   bar  2         1   bar  6
 |      2   baz  3         2   qux  7
 |      3   foo  4         3   bar  8
 |      
 |      >>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
 |         lkey  value_x  rkey  value_y
 |      0  foo   1        foo   5
 |      1  foo   4        foo   5
 |      2  bar   2        bar   6
 |      3  bar   2        bar   8
 |      4  baz   3        NaN   NaN
 |      5  NaN   NaN      qux   7
 |      
 |      Returns
 |      -------
 |      merged : DataFrame
 |          The output type will the be same as 'left', if it is a subclass
 |          of DataFrame.
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      min : Series or DataFrame (if level specified)
 |  
 |  mod(self, other, axis='columns', level=None, fill_value=None)
 |      Modulo of dataframe and other, element-wise (binary operator `mod`).
 |      
 |      Equivalent to ``dataframe % other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rmod
 |  
 |  mode(self, axis=0, numeric_only=False)
 |      Gets the mode(s) of each element along the axis selected. Empty if
 |      nothing has 2+ occurrences. Adds a row for each mode per label, fills
 |      in gaps with nan.
 |      
 |      Note that there could be multiple values returned for the selected
 |      axis (when more than one item share the maximum frequency), which is
 |      the reason why a dataframe is returned. If you want to impute missing
 |      values with the mode in a dataframe ``df``, you can just do this:
 |      ``df.fillna(df.mode().iloc[0])``
 |      
 |      Parameters
 |      ----------
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          * 0 or 'index' : get mode of each column
 |          * 1 or 'columns' : get mode of each row
 |      numeric_only : boolean, default False
 |          if True, only apply to numeric columns
 |      
 |      Returns
 |      -------
 |      modes : DataFrame (sorted)
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({'A': [1, 2, 1, 2, 1, 2, 3]})
 |      >>> df.mode()
 |         A
 |      0  1
 |      1  2
 |  
 |  mul(self, other, axis='columns', level=None, fill_value=None)
 |      Multiplication of dataframe and other, element-wise (binary operator `mul`).
 |      
 |      Equivalent to ``dataframe * other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rmul
 |  
 |  multiply = mul(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  ne(self, other, axis='columns', level=None)
 |      Wrapper for flexible comparison methods ne
 |  
 |  nlargest(self, n, columns, keep='first')
 |      Get the rows of a DataFrame sorted by the `n` largest
 |      values of `columns`.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Number of items to retrieve
 |      columns : list or str
 |          Column name or names to order by
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'a': [1, 10, 8, 11, -1],
 |      ...                 'b': list('abdce'),
 |      ...                 'c': [1.0, 2.0, np.nan, 3.0, 4.0]})
 |      >>> df.nlargest(3, 'a')
 |          a  b   c
 |      3  11  c   3
 |      1  10  b   2
 |      2   8  d NaN
 |  
 |  nsmallest(self, n, columns, keep='first')
 |      Get the rows of a DataFrame sorted by the `n` smallest
 |      values of `columns`.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      n : int
 |          Number of items to retrieve
 |      columns : list or str
 |          Column name or names to order by
 |      keep : {'first', 'last', False}, default 'first'
 |          Where there are duplicate values:
 |          - ``first`` : take the first occurrence.
 |          - ``last`` : take the last occurrence.
 |      
 |      Returns
 |      -------
 |      DataFrame
 |      
 |      Examples
 |      --------
 |      >>> df = DataFrame({'a': [1, 10, 8, 11, -1],
 |      ...                 'b': list('abdce'),
 |      ...                 'c': [1.0, 2.0, np.nan, 3.0, 4.0]})
 |      >>> df.nsmallest(3, 'a')
 |         a  b   c
 |      4 -1  e   4
 |      0  1  a   1
 |      2  8  d NaN
 |  
 |  pivot(self, index=None, columns=None, values=None)
 |      Reshape data (produce a "pivot" table) based on column values. Uses
 |      unique values from index / columns to form axes and return either
 |      DataFrame or Panel, depending on whether you request a single value
 |      column (DataFrame) or all columns (Panel)
 |      
 |      Parameters
 |      ----------
 |      index : string or object, optional
 |          Column name to use to make new frame's index. If None, uses
 |          existing index.
 |      columns : string or object
 |          Column name to use to make new frame's columns
 |      values : string or object, optional
 |          Column name to use for populating new frame's values
 |      
 |      Notes
 |      -----
 |      For finer-tuned control, see hierarchical indexing documentation along
 |      with the related stack/unstack methods
 |      
 |      Examples
 |      --------
 |      >>> df
 |          foo   bar  baz
 |      0   one   A    1.
 |      1   one   B    2.
 |      2   one   C    3.
 |      3   two   A    4.
 |      4   two   B    5.
 |      5   two   C    6.
 |      
 |      >>> df.pivot('foo', 'bar', 'baz')
 |           A   B   C
 |      one  1   2   3
 |      two  4   5   6
 |      
 |      >>> df.pivot('foo', 'bar')['baz']
 |           A   B   C
 |      one  1   2   3
 |      two  4   5   6
 |      
 |      Returns
 |      -------
 |      pivoted : DataFrame
 |          If no values column specified, will have hierarchically indexed
 |          columns
 |  
 |  pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
 |      Create a spreadsheet-style pivot table as a DataFrame. The levels in the
 |      pivot table will be stored in MultiIndex objects (hierarchical indexes) on
 |      the index and columns of the result DataFrame
 |      
 |      Parameters
 |      ----------
 |      data : DataFrame
 |      values : column to aggregate, optional
 |      index : column, Grouper, array, or list of the previous
 |          If an array is passed, it must be the same length as the data. The list
 |          can contain any of the other types (except list).
 |          Keys to group by on the pivot table index.  If an array is passed, it
 |          is being used as the same manner as column values.
 |      columns : column, Grouper, array, or list of the previous
 |          If an array is passed, it must be the same length as the data. The list
 |          can contain any of the other types (except list).
 |          Keys to group by on the pivot table column.  If an array is passed, it
 |          is being used as the same manner as column values.
 |      aggfunc : function or list of functions, default numpy.mean
 |          If list of functions passed, the resulting pivot table will have
 |          hierarchical columns whose top level are the function names (inferred
 |          from the function objects themselves)
 |      fill_value : scalar, default None
 |          Value to replace missing values with
 |      margins : boolean, default False
 |          Add all row / columns (e.g. for subtotal / grand totals)
 |      dropna : boolean, default True
 |          Do not include columns whose entries are all NaN
 |      margins_name : string, default 'All'
 |          Name of the row / column that will contain the totals
 |          when margins is True.
 |      
 |      Examples
 |      --------
 |      >>> df
 |         A   B   C      D
 |      0  foo one small  1
 |      1  foo one large  2
 |      2  foo one large  2
 |      3  foo two small  3
 |      4  foo two small  3
 |      5  bar one large  4
 |      6  bar one small  5
 |      7  bar two small  6
 |      8  bar two large  7
 |      
 |      >>> table = pivot_table(df, values='D', index=['A', 'B'],
 |      ...                     columns=['C'], aggfunc=np.sum)
 |      >>> table
 |                small  large
 |      foo  one  1      4
 |           two  6      NaN
 |      bar  one  5      4
 |           two  6      7
 |      
 |      Returns
 |      -------
 |      table : DataFrame
 |  
 |  pow(self, other, axis='columns', level=None, fill_value=None)
 |      Exponential power of dataframe and other, element-wise (binary operator `pow`).
 |      
 |      Equivalent to ``dataframe ** other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      prod : Series or DataFrame (if level specified)
 |  
 |  product = prod(self, axis=None, skipna=None, level=None, numeric_only=None, **kwargs)
 |  
 |  quantile(self, q=0.5, axis=0, numeric_only=True, interpolation='linear')
 |      Return values at the given quantile over requested axis, a la
 |      numpy.percentile.
 |      
 |      Parameters
 |      ----------
 |      q : float or array-like, default 0.5 (50% quantile)
 |          0 <= q <= 1, the quantile(s) to compute
 |      axis : {0, 1, 'index', 'columns'} (default 0)
 |          0 or 'index' for row-wise, 1 or 'columns' for column-wise
 |      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
 |      -------
 |      quantiles : Series or DataFrame
 |      
 |          - If ``q`` is an array, a DataFrame will be returned where the
 |            index is ``q``, the columns are the columns of self, and the
 |            values are the quantiles.
 |          - If ``q`` is a float, a Series will be returned where the
 |            index is the columns of self and the values are the quantiles.
 |      
 |      Examples
 |      --------
 |      
 |      >>> df = DataFrame(np.array([[1, 1], [2, 10], [3, 100], [4, 100]]),
 |                         columns=['a', 'b'])
 |      >>> df.quantile(.1)
 |      a    1.3
 |      b    3.7
 |      dtype: float64
 |      >>> df.quantile([.1, .5])
 |             a     b
 |      0.1  1.3   3.7
 |      0.5  2.5  55.0
 |  
 |  query(self, expr, inplace=False, **kwargs)
 |      Query the columns of a frame with a boolean expression.
 |      
 |      .. versionadded:: 0.13
 |      
 |      Parameters
 |      ----------
 |      expr : string
 |          The query string to evaluate.  You can refer to variables
 |          in the environment by prefixing them with an '@' character like
 |          ``@a + b``.
 |      inplace : bool
 |          Whether the query should modify the data in place or return
 |          a modified copy
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      kwargs : dict
 |          See the documentation for :func:`pandas.eval` for complete details
 |          on the keyword arguments accepted by :meth:`DataFrame.query`.
 |      
 |      Returns
 |      -------
 |      q : DataFrame
 |      
 |      Notes
 |      -----
 |      The result of the evaluation of this expression is first passed to
 |      :attr:`DataFrame.loc` and if that fails because of a
 |      multidimensional key (e.g., a DataFrame) then the result will be passed
 |      to :meth:`DataFrame.__getitem__`.
 |      
 |      This method uses the top-level :func:`pandas.eval` function to
 |      evaluate the passed query.
 |      
 |      The :meth:`~pandas.DataFrame.query` method uses a slightly
 |      modified Python syntax by default. For example, the ``&`` and ``|``
 |      (bitwise) operators have the precedence of their boolean cousins,
 |      :keyword:`and` and :keyword:`or`. This *is* syntactically valid Python,
 |      however the semantics are different.
 |      
 |      You can change the semantics of the expression by passing the keyword
 |      argument ``parser='python'``. This enforces the same semantics as
 |      evaluation in Python space. Likewise, you can pass ``engine='python'``
 |      to evaluate an expression using Python itself as a backend. This is not
 |      recommended as it is inefficient compared to using ``numexpr`` as the
 |      engine.
 |      
 |      The :attr:`DataFrame.index` and
 |      :attr:`DataFrame.columns` attributes of the
 |      :class:`~pandas.DataFrame` instance are placed in the query namespace
 |      by default, which allows you to treat both the index and columns of the
 |      frame as a column in the frame.
 |      The identifier ``index`` is used for the frame index; you can also
 |      use the name of the index to identify it in a query.
 |      
 |      For further details and examples see the ``query`` documentation in
 |      :ref:`indexing <indexing.query>`.
 |      
 |      See Also
 |      --------
 |      pandas.eval
 |      DataFrame.eval
 |      
 |      Examples
 |      --------
 |      >>> from numpy.random import randn
 |      >>> from pandas import DataFrame
 |      >>> df = DataFrame(randn(10, 2), columns=list('ab'))
 |      >>> df.query('a > b')
 |      >>> df[df.a > df.b]  # same result as the previous expression
 |  
 |  radd(self, other, axis='columns', level=None, fill_value=None)
 |      Addition of dataframe and other, element-wise (binary operator `radd`).
 |      
 |      Equivalent to ``other + dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.add
 |  
 |  rdiv = rtruediv(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  reindex(self, index=None, columns=None, **kwargs)
 |      Conform DataFrame 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, columns : 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.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                   404           0.08
 |      Chrome                 200           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 : DataFrame
 |  
 |  reindex_axis(self, labels, axis=0, method=None, level=None, copy=True, limit=None, fill_value=nan)
 |      Conform input object 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
 |      ----------
 |      labels : array-like
 |          New labels / index to conform to. Preferably an Index object to
 |          avoid duplicating data
 |      axis : {0, 1, 'index', 'columns'}
 |      method : {None, 'backfill'/'bfill', 'pad'/'ffill', 'nearest'}, optional
 |          Method to use for filling holes in reindexed DataFrame:
 |      
 |          * 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
 |      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
 |      --------
 |      >>> df.reindex_axis(['A', 'B', 'C'], axis=1)
 |      
 |      See Also
 |      --------
 |      reindex, reindex_like
 |      
 |      Returns
 |      -------
 |      reindexed : DataFrame
 |  
 |  rename(self, index=None, columns=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. Alternatively, change ``Series.name`` with a scalar
 |      value (Series only).
 |      
 |      Parameters
 |      ----------
 |      index, columns : 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 DataFrame. If True then value of copy is
 |          ignored.
 |      
 |      Returns
 |      -------
 |      renamed : DataFrame (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)
 |      ...
 |      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
 |  
 |  reorder_levels(self, order, axis=0)
 |      Rearrange index levels using input order.
 |      May not drop or duplicate levels
 |      
 |      Parameters
 |      ----------
 |      order : list of int or list of str
 |          List representing new level order. Reference level by number
 |          (position) or by key (label).
 |      axis : int
 |          Where to reorder levels.
 |      
 |      Returns
 |      -------
 |      type of caller (new object)
 |  
 |  reset_index(self, level=None, drop=False, inplace=False, col_level=0, col_fill='')
 |      For DataFrame with multi-level index, return new DataFrame with
 |      labeling information in the columns under the index names, defaulting
 |      to 'level_0', 'level_1', etc. if any are None. For a standard index,
 |      the index name will be used (if set), otherwise a default 'index' or
 |      'level_0' (if 'index' is already taken) will be used.
 |      
 |      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. This resets
 |          the index to the default integer index.
 |      inplace : boolean, default False
 |          Modify the DataFrame in place (do not create a new object)
 |      col_level : int or str, default 0
 |          If the columns have multiple levels, determines which level the
 |          labels are inserted into. By default it is inserted into the first
 |          level.
 |      col_fill : object, default ''
 |          If the columns have multiple levels, determines how the other
 |          levels are named. If None then the index name is repeated.
 |      
 |      Returns
 |      -------
 |      resetted : DataFrame
 |  
 |  rfloordiv(self, other, axis='columns', level=None, fill_value=None)
 |      Integer division of dataframe and other, element-wise (binary operator `rfloordiv`).
 |      
 |      Equivalent to ``other // dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.floordiv
 |  
 |  rmod(self, other, axis='columns', level=None, fill_value=None)
 |      Modulo of dataframe and other, element-wise (binary operator `rmod`).
 |      
 |      Equivalent to ``other % dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mod
 |  
 |  rmul(self, other, axis='columns', level=None, fill_value=None)
 |      Multiplication of dataframe and other, element-wise (binary operator `rmul`).
 |      
 |      Equivalent to ``other * dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.mul
 |  
 |  rolling(self, window, min_periods=None, freq=None, center=False, win_type=None, axis=0)
 |      Provides rolling transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int
 |         Size of the moving window. This is the number of observations used for
 |         calculating the statistic.
 |      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.
 |      win_type : string, default None
 |          prove a window type, see the notes below
 |      axis : int, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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`).
 |      
 |      The recognized window 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, out=None)
 |      Round a DataFrame to a variable number of decimal places.
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      decimals : int, dict, Series
 |          Number of decimal places to round each column to. If an int is
 |          given, round each column to the same number of places.
 |          Otherwise dict and Series round to variable numbers of places.
 |          Column names should be in the keys if `decimals` is a
 |          dict-like, or in the index if `decimals` is a Series. Any
 |          columns not included in `decimals` will be left as is. Elements
 |          of `decimals` which are not columns of the input will be
 |          ignored.
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame(np.random.random([3, 3]),
 |      ...     columns=['A', 'B', 'C'], index=['first', 'second', 'third'])
 |      >>> df
 |                     A         B         C
 |      first   0.028208  0.992815  0.173891
 |      second  0.038683  0.645646  0.577595
 |      third   0.877076  0.149370  0.491027
 |      >>> df.round(2)
 |                 A     B     C
 |      first   0.03  0.99  0.17
 |      second  0.04  0.65  0.58
 |      third   0.88  0.15  0.49
 |      >>> df.round({'A': 1, 'C': 2})
 |                A         B     C
 |      first   0.0  0.992815  0.17
 |      second  0.0  0.645646  0.58
 |      third   0.9  0.149370  0.49
 |      >>> decimals = pd.Series([1, 0, 2], index=['A', 'B', 'C'])
 |      >>> df.round(decimals)
 |                A  B     C
 |      first   0.0  1  0.17
 |      second  0.0  1  0.58
 |      third   0.9  0  0.49
 |      
 |      Returns
 |      -------
 |      DataFrame object
 |      
 |      See Also
 |      --------
 |      numpy.around
 |  
 |  rpow(self, other, axis='columns', level=None, fill_value=None)
 |      Exponential power of dataframe and other, element-wise (binary operator `rpow`).
 |      
 |      Equivalent to ``other ** dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.pow
 |  
 |  rsub(self, other, axis='columns', level=None, fill_value=None)
 |      Subtraction of dataframe and other, element-wise (binary operator `rsub`).
 |      
 |      Equivalent to ``other - dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.sub
 |  
 |  rtruediv(self, other, axis='columns', level=None, fill_value=None)
 |      Floating division of dataframe and other, element-wise (binary operator `rtruediv`).
 |      
 |      Equivalent to ``other / dataframe``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.truediv
 |  
 |  select_dtypes(self, include=None, exclude=None)
 |      Return a subset of a DataFrame including/excluding columns based on
 |      their ``dtype``.
 |      
 |      Parameters
 |      ----------
 |      include, exclude : list-like
 |          A list of dtypes or strings to be included/excluded. You must pass
 |          in a non-empty sequence for at least one of these.
 |      
 |      Raises
 |      ------
 |      ValueError
 |          * If both of ``include`` and ``exclude`` are empty
 |          * If ``include`` and ``exclude`` have overlapping elements
 |          * If any kind of string dtype is passed in.
 |      TypeError
 |          * If either of ``include`` or ``exclude`` is not a sequence
 |      
 |      Returns
 |      -------
 |      subset : DataFrame
 |          The subset of the frame including the dtypes in ``include`` and
 |          excluding the dtypes in ``exclude``.
 |      
 |      Notes
 |      -----
 |      * To select all *numeric* types use the numpy dtype ``numpy.number``
 |      * To select strings you must use the ``object`` dtype, but note that
 |        this will return *all* object dtype columns
 |      * See the `numpy dtype hierarchy
 |        <http://docs.scipy.org/doc/numpy/reference/arrays.scalars.html>`__
 |      * To select Pandas categorical dtypes, use 'category'
 |      
 |      Examples
 |      --------
 |      >>> df = pd.DataFrame({'a': np.random.randn(6).astype('f4'),
 |      ...                    'b': [True, False] * 3,
 |      ...                    'c': [1.0, 2.0] * 3})
 |      >>> df
 |              a      b  c
 |      0  0.3962   True  1
 |      1  0.1459  False  2
 |      2  0.2623   True  1
 |      3  0.0764  False  2
 |      4 -0.9703   True  1
 |      5 -1.2094  False  2
 |      >>> df.select_dtypes(include=['float64'])
 |         c
 |      0  1
 |      1  2
 |      2  1
 |      3  2
 |      4  1
 |      5  2
 |      >>> df.select_dtypes(exclude=['floating'])
 |             b
 |      0   True
 |      1  False
 |      2   True
 |      3  False
 |      4   True
 |      5  False
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sem : Series or DataFrame (if level specified)
 |  
 |  set_index(self, keys, drop=True, append=False, inplace=False, verify_integrity=False)
 |      Set the DataFrame index (row labels) using one or more existing
 |      columns. By default yields a new object.
 |      
 |      Parameters
 |      ----------
 |      keys : column label or list of column labels / arrays
 |      drop : boolean, default True
 |          Delete columns to be used as the new index
 |      append : boolean, default False
 |          Whether to append columns to existing index
 |      inplace : boolean, default False
 |          Modify the DataFrame in place (do not create a new object)
 |      verify_integrity : boolean, default False
 |          Check the new index for duplicates. Otherwise defer the check until
 |          necessary. Setting to False will improve the performance of this
 |          method
 |      
 |      Examples
 |      --------
 |      >>> indexed_df = df.set_index(['A', 'B'])
 |      >>> indexed_df2 = df.set_index(['A', [0, 1, 2, 0, 1, 2]])
 |      >>> indexed_df3 = df.set_index([[0, 1, 2, 0, 1, 2]])
 |      
 |      Returns
 |      -------
 |      dataframe : DataFrame
 |  
 |  set_value(self, index, col, value, takeable=False)
 |      Put single value at passed column and index
 |      
 |      Parameters
 |      ----------
 |      index : row label
 |      col : column label
 |      value : scalar value
 |      takeable : interpret the index/col as indexers, default False
 |      
 |      Returns
 |      -------
 |      frame : DataFrame
 |          If label pair is contained, will be reference to calling DataFrame,
 |          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 datetools module or time rule (e.g. 'EOM').
 |          See Notes.
 |      axis : {0, 1, 'index', 'columns'}
 |      
 |      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 : DataFrame
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      skew : Series or DataFrame (if level specified)
 |  
 |  sort(self, columns=None, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 |      DEPRECATED: use :meth:`DataFrame.sort_values`
 |      
 |      Sort DataFrame either by labels (along either axis) or by the values in
 |      column(s)
 |      
 |      Parameters
 |      ----------
 |      columns : object
 |          Column name(s) in frame. Accepts a column name or a list
 |          for a nested sort. A tuple will be interpreted as the
 |          levels of a multi-index.
 |      ascending : boolean or list, default True
 |          Sort ascending vs. descending. Specify list for multiple sort
 |          orders
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          Sort index/rows versus columns
 |      inplace : boolean, default False
 |          Sort the DataFrame without creating a new instance
 |      kind : {'quicksort', 'mergesort', 'heapsort'}, optional
 |          This option is only applied when sorting on a single column or
 |          label.
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      
 |      Examples
 |      --------
 |      >>> result = df.sort(['A', 'B'], ascending=[1, 0])
 |      
 |      Returns
 |      -------
 |      sorted : DataFrame
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
 |      Sort object by labels (along an axis)
 |      
 |      Parameters
 |      ----------
 |      axis : index, columns 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
 |          if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      sort_remaining : bool
 |          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 : DataFrame
 |  
 |  sort_values(self, by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
 |      Sort by the values along either axis
 |      
 |      .. versionadded:: 0.17.0
 |      
 |      Parameters
 |      ----------
 |      by : string name or list of names which refer to the axis items
 |      axis : index, columns to direct sorting
 |      ascending : bool or list of bool
 |           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
 |           if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      
 |      Returns
 |      -------
 |      sorted_obj : DataFrame
 |  
 |  sortlevel(self, level=0, axis=0, ascending=True, inplace=False, sort_remaining=True)
 |      Sort multilevel index by chosen axis and primary level. Data will be
 |      lexicographically sorted by the chosen level followed by the other
 |      levels (in order)
 |      
 |      Parameters
 |      ----------
 |      level : int
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |      ascending : boolean, default True
 |      inplace : boolean, default False
 |          Sort the DataFrame without creating a new instance
 |      sort_remaining : boolean, default True
 |          Sort by the other levels too.
 |      
 |      Returns
 |      -------
 |      sorted : DataFrame
 |      
 |      See Also
 |      --------
 |      DataFrame.sort_index(level=...)
 |  
 |  stack(self, level=-1, dropna=True)
 |      Pivot a level of the (possibly hierarchical) column labels, returning a
 |      DataFrame (or Series in the case of an object with a single level of
 |      column labels) having a hierarchical index with a new inner-most level
 |      of row labels.
 |      The level involved will automatically get sorted.
 |      
 |      Parameters
 |      ----------
 |      level : int, string, or list of these, default last level
 |          Level(s) to stack, can pass level name
 |      dropna : boolean, default True
 |          Whether to drop rows in the resulting Frame/Series with no valid
 |          values
 |      
 |      Examples
 |      ----------
 |      >>> s
 |           a   b
 |      one  1.  2.
 |      two  3.  4.
 |      
 |      >>> s.stack()
 |      one a    1
 |          b    2
 |      two a    3
 |          b    4
 |      
 |      Returns
 |      -------
 |      stacked : DataFrame or Series
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      std : Series or DataFrame (if level specified)
 |  
 |  sub(self, other, axis='columns', level=None, fill_value=None)
 |      Subtraction of dataframe and other, element-wise (binary operator `sub`).
 |      
 |      Equivalent to ``dataframe - other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rsub
 |  
 |  subtract = sub(self, other, axis='columns', level=None, fill_value=None)
 |  
 |  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), columns (1)}
 |      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 Series
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sum : Series or DataFrame (if level specified)
 |  
 |  swaplevel(self, i, j, axis=0)
 |      Swap levels i and j in a MultiIndex on a particular axis
 |      
 |      Parameters
 |      ----------
 |      i, j : int, string (can be mixed)
 |          Level of index to be swapped. Can pass level name as string.
 |      
 |      Returns
 |      -------
 |      swapped : type of caller (new object)
 |  
 |  to_csv(self, path_or_buf=None, sep=',', na_rep='', float_format=None, columns=None, header=True, index=True, index_label=None, mode='w', encoding=None, compression=None, quoting=None, quotechar='"', line_terminator='\n', chunksize=None, tupleize_cols=False, date_format=None, doublequote=True, escapechar=None, decimal='.', **kwds)
 |      Write DataFrame to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : string or file handle, default None
 |          File path or object, if None is provided the result is returned as
 |          a string.
 |      sep : character, default ','
 |          Field delimiter for the output file.
 |      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, or False, 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.  If
 |          False do not print fields for index names. Use index_label=False
 |          for easier importing in R
 |      nanRep : None
 |          deprecated, use na_rep
 |      mode : str
 |          Python write mode, default 'w'
 |      encoding : string, optional
 |          A string representing the encoding to use in the output file,
 |          defaults to 'ascii' on Python 2 and 'utf-8' on Python 3.
 |      compression : string, optional
 |          a string representing the compression to use in the output file,
 |          allowed values are 'gzip', 'bz2',
 |          only used when the first argument is a filename
 |      line_terminator : string, default '\n'
 |          The newline character or character sequence to use in the output
 |          file
 |      quoting : optional constant from csv module
 |          defaults to csv.QUOTE_MINIMAL
 |      quotechar : string (length 1), default '"'
 |          character used to quote fields
 |      doublequote : boolean, default True
 |          Control quoting of `quotechar` inside a field
 |      escapechar : string (length 1), default None
 |          character used to escape `sep` and `quotechar` when appropriate
 |      chunksize : int or None
 |          rows to write at a time
 |      tupleize_cols : boolean, default False
 |          write multi_index columns as a list of tuples (if True)
 |          or new (expanded format) if False)
 |      date_format : string, default None
 |          Format string for datetime objects
 |      decimal: string, default '.'
 |          Character recognized as decimal separator. E.g. use ',' for
 |          European data
 |      
 |          .. versionadded:: 0.16.0
 |  
 |  to_dict(self, orient='dict')
 |      Convert DataFrame to dictionary.
 |      
 |      Parameters
 |      ----------
 |      orient : str {'dict', 'list', 'series', 'split', 'records', 'index'}
 |          Determines the type of the values of the dictionary.
 |      
 |          - dict (default) : dict like {column -> {index -> value}}
 |          - list : dict like {column -> [values]}
 |          - series : dict like {column -> Series(values)}
 |          - split : dict like
 |            {index -> [index], columns -> [columns], data -> [values]}
 |          - records : list like
 |            [{column -> value}, ... , {column -> value}]
 |          - index : dict like {index -> {column -> value}}
 |      
 |            .. versionadded:: 0.17.0
 |      
 |          Abbreviations are allowed. `s` indicates `series` and `sp`
 |          indicates `split`.
 |      
 |      Returns
 |      -------
 |      result : dict like {column -> {index -> value}}
 |  
 |  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 DataFrame to a excel sheet
 |      
 |      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)
 |      
 |      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 = 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_gbq(self, destination_table, project_id, chunksize=10000, verbose=True, reauth=False, if_exists='fail', private_key=None)
 |      Write a DataFrame to a Google BigQuery table.
 |      
 |      THIS IS AN EXPERIMENTAL LIBRARY
 |      
 |      Parameters
 |      ----------
 |      dataframe : DataFrame
 |          DataFrame to be written
 |      destination_table : string
 |          Name of table to be written, in the form 'dataset.tablename'
 |      project_id : str
 |          Google BigQuery Account project ID.
 |      chunksize : int (default 10000)
 |          Number of rows to be inserted in each chunk from the dataframe.
 |      verbose : boolean (default True)
 |          Show percentage complete
 |      reauth : boolean (default False)
 |          Force Google BigQuery to reauthenticate the user. This is useful
 |          if multiple accounts are used.
 |      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.
 |      private_key : str (optional)
 |          Service account private key in JSON format. Can be file path
 |          or string contents. This is useful for remote server
 |          authentication (eg. jupyter iPython notebook on remote host)
 |      
 |          .. versionadded:: 0.17.0
 |  
 |  to_html(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, bold_rows=True, classes=None, escape=True, max_rows=None, max_cols=None, show_dimensions=False, notebook=False, decimal='.')
 |      Render a DataFrame as an HTML table.
 |      
 |      `to_html`-specific options:
 |      
 |      bold_rows : boolean, default True
 |          Make the row labels bold in the output
 |      classes : str or list or tuple, default None
 |          CSS class(es) to apply to the resulting html table
 |      escape : boolean, default True
 |          Convert the characters <, >, and & to HTML-safe sequences.=
 |      max_rows : int, optional
 |          Maximum number of rows to show before truncating. If None, show
 |          all.
 |      max_cols : int, optional
 |          Maximum number of columns to show before truncating. If None, show
 |          all.
 |      decimal : string, default '.'
 |          Character recognized as decimal separator, e.g. ',' in Europe
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      justify : {'left', 'right'}, default None
 |          Left or right-justify the column labels. If None uses the option from
 |          the print configuration (controlled by set_option), 'right' out
 |          of the box.
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_latex(self, buf=None, columns=None, col_space=None, colSpace=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, bold_rows=True, column_format=None, longtable=None, escape=None, encoding=None, decimal='.')
 |      Render a DataFrame to a tabular environment table. You can splice
 |      this into a LaTeX document. Requires \usepackage{booktabs}.
 |      
 |      `to_latex`-specific options:
 |      
 |      bold_rows : boolean, default True
 |          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
 |          Default encoding is ascii in Python 2 and utf-8 in Python 3
 |      decimal : string, default '.'
 |          Character recognized as decimal separator, e.g. ',' in Europe
 |      
 |          .. versionadded:: 0.18.0
 |      
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_panel(self)
 |      Transform long (stacked) format (DataFrame) into wide (3D, Panel)
 |      format.
 |      
 |      Currently the index of the DataFrame must be a 2-level MultiIndex. This
 |      may be generalized later
 |      
 |      Returns
 |      -------
 |      panel : Panel
 |  
 |  to_period(self, freq=None, axis=0, copy=True)
 |      Convert DataFrame from DatetimeIndex to PeriodIndex with desired
 |      frequency (inferred from index if not passed)
 |      
 |      Parameters
 |      ----------
 |      freq : string, default
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          The axis to convert (the index by default)
 |      copy : boolean, default True
 |          If False then underlying input data is not copied
 |      
 |      Returns
 |      -------
 |      ts : TimeSeries with PeriodIndex
 |  
 |  to_records(self, index=True, convert_datetime64=True)
 |      Convert DataFrame to record array. Index will be put in the
 |      'index' field of the record array if requested
 |      
 |      Parameters
 |      ----------
 |      index : boolean, default True
 |          Include index in resulting record array, stored in 'index' field
 |      convert_datetime64 : boolean, default True
 |          Whether to convert the index to datetime.datetime if it is a
 |          DatetimeIndex
 |      
 |      Returns
 |      -------
 |      y : recarray
 |  
 |  to_sparse(self, fill_value=None, kind='block')
 |      Convert to SparseDataFrame
 |      
 |      Parameters
 |      ----------
 |      fill_value : float, default NaN
 |      kind : {'block', 'integer'}
 |      
 |      Returns
 |      -------
 |      y : SparseDataFrame
 |  
 |  to_stata(self, fname, convert_dates=None, write_index=True, encoding='latin-1', byteorder=None, time_stamp=None, data_label=None)
 |      A class for writing Stata binary dta files from array-like objects
 |      
 |      Parameters
 |      ----------
 |      fname : file path or buffer
 |          Where to save the dta file.
 |      convert_dates : dict
 |          Dictionary mapping column of datetime types to the stata internal
 |          format that you want to use for the dates. Options are
 |          'tc', 'td', 'tm', 'tw', 'th', 'tq', 'ty'. Column can be either a
 |          number or a name.
 |      encoding : str
 |          Default is latin-1. Note that Stata does not support unicode.
 |      byteorder : str
 |          Can be ">", "<", "little", or "big". The default is None which uses
 |          `sys.byteorder`
 |      
 |      Examples
 |      --------
 |      >>> writer = StataWriter('./data_file.dta', data)
 |      >>> writer.write_file()
 |      
 |      Or with dates
 |      
 |      >>> writer = StataWriter('./date_data_file.dta', data, {2 : 'tw'})
 |      >>> writer.write_file()
 |  
 |  to_string(self, buf=None, columns=None, col_space=None, header=True, index=True, na_rep='NaN', formatters=None, float_format=None, sparsify=None, index_names=True, justify=None, line_width=None, max_rows=None, max_cols=None, show_dimensions=False)
 |      Render a DataFrame to a console-friendly tabular output.
 |      
 |      Parameters
 |      ----------
 |      buf : StringIO-like, optional
 |          buffer to write to
 |      columns : sequence, optional
 |          the subset of columns to write; default None writes all columns
 |      col_space : int, optional
 |          the minimum width of each column
 |      header : bool, optional
 |          whether to print column labels, default True
 |      index : bool, optional
 |          whether to print index (row) labels, default True
 |      na_rep : string, optional
 |          string representation of NAN to use, default 'NaN'
 |      formatters : list or dict of one-parameter functions, optional
 |          formatter functions to apply to columns' elements by position or name,
 |          default None. The result of each function must be a unicode string.
 |          List must be of length equal to the number of columns.
 |      float_format : one-parameter function, optional
 |          formatter function to apply to columns' elements if they are floats,
 |          default None. The result of this function must be a unicode string.
 |      sparsify : bool, optional
 |          Set to False for a DataFrame with a hierarchical index to print every
 |          multiindex key at each row, default True
 |      index_names : bool, optional
 |          Prints the names of the indexes, default True
 |      justify : {'left', 'right'}, default None
 |          Left or right-justify the column labels. If None uses the option from
 |          the print configuration (controlled by set_option), 'right' out
 |          of the box.
 |      
 |      Returns
 |      -------
 |      formatted : string (or unicode, depending on data and options)
 |  
 |  to_timestamp(self, freq=None, how='start', axis=0, 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
 |      axis : {0 or 'index', 1 or 'columns'}, default 0
 |          The axis to convert (the index by default)
 |      copy : boolean, default True
 |          If false then underlying input data is not copied
 |      
 |      Returns
 |      -------
 |      df : DataFrame with DatetimeIndex
 |  
 |  to_wide = wrapper(*args, **kwargs)
 |  
 |  transpose(self)
 |      Transpose index and columns
 |  
 |  truediv(self, other, axis='columns', level=None, fill_value=None)
 |      Floating division of dataframe and other, element-wise (binary operator `truediv`).
 |      
 |      Equivalent to ``dataframe / other``, but with support to substitute a fill_value for
 |      missing data in one of the inputs.
 |      
 |      Parameters
 |      ----------
 |      other : Series, DataFrame, or constant
 |      axis : {0, 1, 'index', 'columns'}
 |          For Series input, axis to match Series index on
 |      fill_value : None or float value, default None
 |          Fill missing (NaN) values with this value. If both DataFrame
 |          locations are missing, the result will be missing
 |      level : int or name
 |          Broadcast across a level, matching Index values on the
 |          passed MultiIndex level
 |      
 |      Notes
 |      -----
 |      Mismatched indices will be unioned together
 |      
 |      Returns
 |      -------
 |      result : DataFrame
 |      
 |      See also
 |      --------
 |      DataFrame.rtruediv
 |  
 |  unstack(self, level=-1, fill_value=None)
 |      Pivot a level of the (necessarily hierarchical) index labels, returning
 |      a DataFrame having a new level of column labels whose inner-most level
 |      consists of the pivoted index labels. If the index is not a MultiIndex,
 |      the output will be a Series (the analogue of stack when the columns are
 |      not a MultiIndex).
 |      The level involved will automatically get sorted.
 |      
 |      Parameters
 |      ----------
 |      level : int, string, or list of these, default -1 (last level)
 |          Level(s) of index to unstack, can pass level name
 |      fill_value : replace NaN with this value if the unstack produces
 |          missing values
 |      
 |          .. versionadded: 0.18.0
 |      
 |      See also
 |      --------
 |      DataFrame.pivot : Pivot a table based on column values.
 |      DataFrame.stack : Pivot a level of the column labels (inverse operation
 |          from `unstack`).
 |      
 |      Examples
 |      --------
 |      >>> index = pd.MultiIndex.from_tuples([('one', 'a'), ('one', 'b'),
 |      ...                                    ('two', 'a'), ('two', 'b')])
 |      >>> s = pd.Series(np.arange(1.0, 5.0), index=index)
 |      >>> s
 |      one  a   1
 |           b   2
 |      two  a   3
 |           b   4
 |      dtype: float64
 |      
 |      >>> s.unstack(level=-1)
 |           a   b
 |      one  1  2
 |      two  3  4
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a  1   3
 |      b  2   4
 |      
 |      >>> df = s.unstack(level=0)
 |      >>> df.unstack()
 |      one  a  1.
 |           b  3.
 |      two  a  2.
 |           b  4.
 |      
 |      Returns
 |      -------
 |      unstacked : DataFrame or Series
 |  
 |  update(self, other, join='left', overwrite=True, filter_func=None, raise_conflict=False)
 |      Modify DataFrame in place using non-NA values from passed
 |      DataFrame. Aligns on indices
 |      
 |      Parameters
 |      ----------
 |      other : DataFrame, or object coercible into a DataFrame
 |      join : {'left'}, default 'left'
 |      overwrite : boolean, default True
 |          If True then overwrite values for common keys in the calling frame
 |      filter_func : callable(1d-array) -> 1d-array<boolean>, default None
 |          Can choose to replace values other than NA. Return True for values
 |          that should be updated
 |      raise_conflict : boolean
 |          If True, will raise an error if the DataFrame and other both
 |          contain data in the same place.
 |  
 |  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), columns (1)}
 |      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 Series
 |      ddof : int, default 1
 |          degrees of freedom
 |      numeric_only : boolean, default None
 |          Include only float, int, boolean data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      var : Series or DataFrame (if level specified)
 |  
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |  
 |  from_csv(path, header=0, sep=',', index_col=0, parse_dates=True, encoding=None, tupleize_cols=False, 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 DataFrame of time series data.
 |      
 |      This method only differs from the preferred :func:`pandas.read_csv`
 |      in some defaults:
 |      
 |      - `index_col` is ``0`` instead of ``None`` (take first column as index
 |        by default)
 |      - `parse_dates` is ``True`` instead of ``False`` (try parsing the index
 |        as datetime by default)
 |      
 |      So a ``pd.DataFrame.from_csv(path)`` can be replaced by
 |      ``pd.read_csv(path, index_col=0, parse_dates=True)``.
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO
 |      header : int, default 0
 |          Row to use as header (skip prior rows)
 |      sep : string, default ','
 |          Field delimiter
 |      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
 |      parse_dates : boolean, default True
 |          Parse dates. Different default from read_table
 |      tupleize_cols : boolean, default False
 |          write multi_index columns as a list of tuples (if True)
 |          or new (expanded format) if False)
 |      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 : DataFrame
 |  
 |  from_dict(data, orient='columns', dtype=None) from builtins.type
 |      Construct DataFrame from dict of array-like or dicts
 |      
 |      Parameters
 |      ----------
 |      data : dict
 |          {field : array-like} or {field : dict}
 |      orient : {'columns', 'index'}, default 'columns'
 |          The "orientation" of the data. If the keys of the passed dict
 |          should be the columns of the resulting DataFrame, pass 'columns'
 |          (default). Otherwise if the keys should be rows, pass 'index'.
 |      dtype : dtype, default None
 |          Data type to force, otherwise infer
 |      
 |      Returns
 |      -------
 |      DataFrame
 |  
 |  from_items(items, columns=None, orient='columns') from builtins.type
 |      Convert (key, value) pairs to DataFrame. The keys will be the axis
 |      index (usually the columns, but depends on the specified
 |      orientation). The values should be arrays or Series.
 |      
 |      Parameters
 |      ----------
 |      items : sequence of (key, value) pairs
 |          Values should be arrays or Series.
 |      columns : sequence of column labels, optional
 |          Must be passed if orient='index'.
 |      orient : {'columns', 'index'}, default 'columns'
 |          The "orientation" of the data. If the keys of the
 |          input correspond to column labels, pass 'columns'
 |          (default). Otherwise if the keys correspond to the index,
 |          pass 'index'.
 |      
 |      Returns
 |      -------
 |      frame : DataFrame
 |  
 |  from_records(data, index=None, exclude=None, columns=None, coerce_float=False, nrows=None) from builtins.type
 |      Convert structured or record ndarray to DataFrame
 |      
 |      Parameters
 |      ----------
 |      data : ndarray (structured dtype), list of tuples, dict, or DataFrame
 |      index : string, list of fields, array-like
 |          Field of array to use as the index, alternately a specific set of
 |          input labels to use
 |      exclude : sequence, default None
 |          Columns or fields to exclude
 |      columns : sequence, default None
 |          Column names to use. If the passed data do not have names
 |          associated with them, this argument provides names for the
 |          columns. Otherwise this argument indicates the order of the columns
 |          in the result (any names not found in the data will become all-NA
 |          columns)
 |      coerce_float : boolean, default False
 |          Attempt to convert values to non-string, non-numeric objects (like
 |          decimal.Decimal) to floating point, useful for SQL result sets
 |      
 |      Returns
 |      -------
 |      df : DataFrame
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors defined here:
 |  
 |  T
 |      Transpose index and columns
 |  
 |  axes
 |      Return a list with the row axis labels and column axis labels as the
 |      only members. They are returned in that order.
 |  
 |  columns
 |  
 |  index
 |  
 |  shape
 |      Return a tuple representing the dimensionality of the DataFrame.
 |  
 |  style
 |      Property returning a Styler object containing methods for
 |      building a styled HTML representation fo the DataFrame.
 |      
 |      See Also
 |      --------
 |      pandas.core.style.Styler
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  plot = <class 'pandas.tools.plotting.FramePlotMethods'>
 |      DataFrame plotting accessor and method
 |      
 |      Examples
 |      --------
 |      >>> df.plot.line()
 |      >>> df.plot.scatter('x', 'y')
 |      >>> df.plot.hexbin()
 |      
 |      These plotting methods can also be accessed by calling the accessor as a
 |      method with the ``kind`` argument:
 |      ``df.plot(kind='line')`` is equivalent to ``df.plot.line()``
 |  
 |  ----------------------------------------------------------------------
 |  Methods inherited from pandas.core.generic.NDFrame:
 |  
 |  __abs__(self)
 |  
 |  __array__(self, dtype=None)
 |  
 |  __array_wrap__(self, result, context=None)
 |  
 |  __bool__ = __nonzero__(self)
 |  
 |  __contains__(self, key)
 |      True if the key is in the info axis
 |  
 |  __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)
 |  
 |  __iter__(self)
 |      Iterate over infor axis
 |  
 |  __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.
 |      
 |      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)
 |      Convert all TimeSeries inside to specified frequency using DateOffset
 |      objects. Optionally provide fill method to pad/backfill missing values.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill', 'bfill', 'pad', 'ffill', 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 method
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |  
 |  astype(self, dtype, copy=True, raise_on_error=True, **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : numpy.dtype or Python type
 |      raise_on_error : raise on invalid input
 |      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 NDFrame.fillna(method='bfill')
 |  
 |  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, out=None, axis=None)
 |      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)
 |      Compute NDFrame with "consolidated" internals (data of each dtype
 |      grouped together in a single ndarray). Mainly an internal API function,
 |      but available here to the savvy user
 |      
 |      Parameters
 |      ----------
 |      inplace : boolean, default False
 |          If False return new object, otherwise modify existing object
 |      
 |      Returns
 |      -------
 |      consolidated : type of caller
 |  
 |  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 object
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, i.e. also copy data
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generate various summary statistics, excluding NaN values.
 |      
 |      Parameters
 |      ----------
 |      percentiles : array-like, optional
 |          The percentiles to include in the output. Should all
 |          be in the interval [0, 1]. By default `percentiles` is
 |          [.25, .5, .75], returning the 25th, 50th, and 75th percentiles.
 |      include, exclude : list-like, 'all', or None (default)
 |          Specify the form of the returned result. Either:
 |      
 |          - None to both (default). The result will include only
 |            numeric-typed columns or, if none are, only categorical columns.
 |          - A list of dtypes or strings to be included/excluded.
 |            To select all numeric types use numpy numpy.number. To select
 |            categorical objects use type object. See also the select_dtypes
 |            documentation. eg. df.describe(include=['O'])
 |          - If include is the string 'all', the output column-set will
 |            match the input one.
 |      
 |      Returns
 |      -------
 |      summary: NDFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      The output DataFrame index depends on the requested dtypes:
 |      
 |      For numeric dtypes, it will include: count, mean, std, min,
 |      max, and lower, 50, and upper percentiles.
 |      
 |      For object dtypes (e.g. timestamps or strings), the index
 |      will include the count, unique, most common, and frequency of the
 |      most common. Timestamps also include the first and last items.
 |      
 |      For mixed dtypes, the index will be the union of the corresponding
 |      output types. Non-applicable entries will be filled with NaN.
 |      Note that mixed-dtype outputs can only be returned from mixed-dtype
 |      inputs and appropriate use of the include/exclude arguments.
 |      
 |      If multiple values have the highest count, then the
 |      `count` and `most common` pair will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      The include, exclude arguments are ignored for Series.
 |      
 |      See Also
 |      --------
 |      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 NDFrame.fillna(method='ffill')
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Restrict the info axis to set of items or wildcard
 |      
 |      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 None
 |          The axis to filter on. By default this is the info axis. The "info
 |          axis" is the axis that is used when indexing with ``[]``. For
 |          example, ``df = DataFrame({'a': [1, 2, 3, 4]]}); df['a']``. So,
 |          the ``DataFrame`` columns are the info axis.
 |      
 |      Notes
 |      -----
 |      Arguments are mutually exclusive, but this is not checked for
 |  
 |  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.
 |  
 |  get_values(self)
 |      same as values (but handles sparseness conversions)
 |  
 |  groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False)
 |      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 / list of functions, dict, Series, or tuple /
 |          list of column names.
 |          Called on each element of the object index to determine the groups.
 |          If a dict or Series is passed, the Series or dict VALUES will be
 |          used to determine the groups
 |      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', 'pchip'}
 |      
 |          * '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', and 'pchip' are all
 |            wrappers around the scipy interpolation methods of similar
 |            names. These use the actual numerical values of the index. See
 |            the scipy documentation for more on their behavior
 |            `here <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__  # noqa
 |            `and here <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__  # noqa
 |      
 |      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.
 |      limit_direction : {'forward', 'backward', 'both'}, defaults to '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
 |  
 |  iterkv(self, *args, **kwargs)
 |      iteritems alias used to get around 2to3. Deprecated
 |  
 |  keys(self)
 |      Get the 'info axis' (see Indexing for more)
 |      
 |      This is index for Series, columns for DataFrame and major_axis for
 |      Panel.
 |  
 |  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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  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 scaler 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)
 |      Convenience method for frequency conversion and resampling of regular
 |      time-series data.
 |      
 |      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
 |      
 |      
 |      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
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00     1
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00     2
 |      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
 |  
 |  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)
 |      Squeeze length 1 dimensions.
 |  
 |  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
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=True)
 |      Analogous to ndarray.take
 |      
 |      Parameters
 |      ----------
 |      indices : list / array of ints
 |      axis : int, default 0
 |      convert : translate neg to pos indices (default)
 |      is_copy : mark the returned frame as a copy
 |      
 |      Returns
 |      -------
 |      taken : type of caller
 |  
 |  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)
 |      Activate the HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          indentifier for the group in the store
 |      mode : optional, {'a', 'w', 'r', 'r+'}, default 'a'
 |      
 |        ``'r'``
 |            Read-only; no data can be modified.
 |        ``'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
 |      complevel : int, 1-9, default 0
 |          If a complib is specified compression will be applied
 |          where possible
 |      complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
 |          If complevel is > 0 apply compression to objects written
 |          in the store wherever possible
 |      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='epoch', double_precision=10, force_ascii=True, date_unit='ms', default_handler=None)
 |      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
 |      
 |      date_format : {'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso`` = ISO8601, 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.
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |  
 |  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)
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |  
 |  to_sql(self, name, con, flavor='sqlite', 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', 'mysql'}, default 'sqlite'
 |          The flavor of SQL to use. Ignored when using SQLAlchemy engine.
 |          'mysql' is deprecated and will be removed in future versions, but
 |          it will be further supported through SQLAlchemy engines.
 |      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
 |      dates.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before date
 |      after : date
 |          Truncate after date
 |      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 datetools 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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  xs(self, key, axis=0, level=None, copy=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.
 |      copy : boolean [deprecated]
 |          Whether to make a copy of the data
 |      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()
 |  
 |  dtypes
 |      Return the dtypes in this object.
 |  
 |  empty
 |      True if NDFrame is entirely empty [no items], meaning any of the
 |      axes are of length 0.
 |      
 |      Notes
 |      -----
 |      If NDFrame contains only NaNs, it is still not considered empty. See
 |      the example below.
 |      
 |      Examples
 |      --------
 |      An example of an actual empty DataFrame. Notice the index is empty:
 |      
 |      >>> df_empty = pd.DataFrame({'A' : []})
 |      >>> df_empty
 |      Empty DataFrame
 |      Columns: [A]
 |      Index: []
 |      >>> df_empty.empty
 |      True
 |      
 |      If we only have NaNs in our DataFrame, it is not considered empty! We
 |      will need to drop the NaNs to make the DataFrame empty:
 |      
 |      >>> df = pd.DataFrame({'A' : [np.nan]})
 |      >>> df
 |          A
 |      0 NaN
 |      >>> df.empty
 |      False
 |      >>> df.dropna().empty
 |      True
 |      
 |      See also
 |      --------
 |      pandas.Series.dropna
 |      pandas.DataFrame.dropna
 |  
 |  ftypes
 |      Return the ftypes (indication of sparse/dense and dtype)
 |      in this object.
 |  
 |  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.
 |      
 |      ``.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.
 |      
 |      ``.loc`` will raise a ``KeyError`` when the items are not found.
 |      
 |      See more at :ref:`Selection by Label <indexing.label>`
 |  
 |  ndim
 |      Number of axes / array dimensions
 |  
 |  size
 |      number of elements in the NDFrame
 |  
 |  values
 |      Numpy representation of NDFrame
 |      
 |      Notes
 |      -----
 |      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.
 |  
 |  ----------------------------------------------------------------------
 |  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.
 |  
 |  ----------------------------------------------------------------------
 |  Data descriptors inherited from pandas.core.base.StringMixin:
 |  
 |  __dict__
 |      dictionary for instance variables (if defined)
 |  
 |  __weakref__
 |      list of weak references to the object (if defined)

In [58]:

    

frame.state


    

    
Out[58]:





0      Ohio
1      Ohio
2      Ohio
3    Nevada
4    Nevada
Name: state, dtype: object

In [59]:

    

help(frame.state)


    

    




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 any 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 unique and hashable, same length as data. Index
 |      object (or other iterable of same length as data) 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
 |      builtins.object
 |  
 |  Methods defined here:
 |  
 |  __add__ = wrapper(left, right, name='__add__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d6a8>)
 |  
 |  __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 0x10945dae8>)
 |  
 |  __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 0x10945dbf8>)
 |  
 |  __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 0x10945dd08>)
 |  
 |  __mul__ = wrapper(left, right, name='__mul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d9d8>)
 |  
 |  __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 0x10945de18>)
 |  
 |  __radd__ = wrapper(left, right, name='__radd__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d7b8>)
 |  
 |  __rand__ = wrapper(self, other)
 |  
 |  __rdiv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rfloordiv__ = wrapper(left, right, name='__rfloordiv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463488>)
 |  
 |  __rmod__ = wrapper(left, right, name='__rmod__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094637b8>)
 |  
 |  __rmul__ = wrapper(left, right, name='__rmul__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945df28>)
 |  
 |  __ror__ = wrapper(self, other)
 |  
 |  __rpow__ = wrapper(left, right, name='__rpow__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463620>)
 |  
 |  __rsub__ = wrapper(left, right, name='__rsub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x109463158>)
 |  
 |  __rtruediv__ = wrapper(left, right, name='__rtruediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x1094632f0>)
 |  
 |  __rxor__ = wrapper(self, other)
 |  
 |  __setitem__(self, key, value)
 |  
 |  __sub__ = wrapper(left, right, name='__sub__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945d8c8>)
 |  
 |  __truediv__ = wrapper(left, right, name='__truediv__', na_op=<function _arith_method_SERIES.<locals>.na_op at 0x10945dae8>)
 |  
 |  __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
 |  
 |  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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      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 data. If None, will attempt to use everything,
 |          then use only boolean data
 |      
 |      Returns
 |      -------
 |      any : scalar or Series (if level specified)
 |  
 |  append(self, to_append, verify_integrity=False)
 |      Concatenate two or more Series.
 |      
 |      Parameters
 |      ----------
 |      to_append : Series or list/tuple of Series
 |      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 `verify_integrity` set to True:
 |      
 |      >>> s1.append(s2, verify_integrity=True)
 |      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
 |      
 |      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'])
 |      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, out=None, skipna=True)
 |  
 |  argmin = idxmin(self, axis=None, out=None, skipna=True)
 |  
 |  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
 |  
 |  asof(self, where)
 |      Return last good (non-NaN) value in Series if value is NaN for
 |      requested date.
 |      
 |      If there is no good value, NaN is returned.
 |      
 |      Parameters
 |      ----------
 |      where : date or array of dates
 |      
 |      Notes
 |      -----
 |      Dates are assumed to be sorted
 |      
 |      Returns
 |      -------
 |      value or NaN
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      compounded : scalar or Series (if level specified)
 |  
 |  compress(self, condition, axis=0, out=None, **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 = max(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      max : scalar
 |  
 |  cummin = min(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative min 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
 |      -------
 |      min : scalar
 |  
 |  cumprod = prod(self, axis=None, dtype=None, out=None, skipna=True, **kwargs)
 |      Return cumulative prod 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
 |      -------
 |      prod : scalar
 |  
 |  cumsum = sum(self, axis=None, dtype=None, out=None, skipna=True, **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
 |      -------
 |      sum : scalar
 |  
 |  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.
 |      take_last : deprecated
 |      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``.
 |      take_last : deprecated
 |      
 |      Returns
 |      -------
 |      duplicated : Series
 |  
 |  eq = wrapper(self, other, axis=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
 |      
 |      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, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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.
 |      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 = wrapper(self, other, axis=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 = wrapper(self, other, axis=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, out=None, skipna=True)
 |      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, out=None, skipna=True)
 |      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
 |  
 |  iget(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  iget_value(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  irow(self, i, axis=0)
 |      DEPRECATED. Use ``.iloc[i]`` or ``.iat[i]`` instead
 |  
 |  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 : 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.
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 = wrapper(self, other, axis=None)
 |  
 |  lt = wrapper(self, other, axis=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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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
 |      
 |      Examples
 |      --------
 |      >>> x
 |      one   1
 |      two   2
 |      three 3
 |      
 |      >>> y
 |      1  foo
 |      2  bar
 |      3  baz
 |      
 |      >>> x.map(y)
 |      one   foo
 |      two   bar
 |      three baz
 |      
 |      Returns
 |      -------
 |      y : Series
 |          same index as caller
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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)
 |      Returns the mode(s) of the dataset.
 |      
 |      Empty if nothing occurs at least 2 times.  Always returns Series even
 |      if only one value.
 |      
 |      Parameters
 |      ----------
 |      sort : bool, default True
 |          If True, will lexicographically sort values, if False skips
 |          sorting. Result ordering when ``sort=False`` is not defined.
 |      
 |      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 = wrapper(self, other, axis=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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nlargest(10)  # only sorts up to the N requested
 |  
 |  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.
 |      take_last : deprecated
 |      
 |      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(1e6))
 |      >>> s.nsmallest(10)  # only sorts up to the N requested
 |  
 |  order(self, na_last=None, ascending=True, kind='quicksort', na_position='last', inplace=False)
 |      DEPRECATED: use :meth:`Series.sort_values`
 |      
 |      Sorts Series object, by value, maintaining index-value link.
 |      This will return a new Series by default. Series.sort is the equivalent
 |      but as an inplace method.
 |      
 |      Parameters
 |      ----------
 |      na_last : boolean (optional, default=True)--DEPRECATED; use na_position
 |          Put NaN's at beginning or end
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default False
 |          Do operation in place.
 |      
 |      Returns
 |      -------
 |      y : Series
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      ptp : scalar or Series (if level specified)
 |  
 |  put(self, *args, **kwargs)
 |      return a ndarray with the values put
 |      
 |      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.07
 |      Iceweasel              NaN            NaN
 |      Comodo Dragon          NaN            NaN
 |      IE10                   404           0.08
 |      Chrome                 200           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. 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.
 |      
 |      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)
 |      ...
 |      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
 |  
 |  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, reps)
 |      return a new Series with the values repeated reps times
 |      
 |      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)
 |      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.take
 |  
 |  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, axis=0)
 |      Provides rolling transformations.
 |      
 |      .. versionadded:: 0.18.0
 |      
 |      Parameters
 |      ----------
 |      window : int
 |         Size of the moving window. This is the number of observations used for
 |         calculating the statistic.
 |      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.
 |      win_type : string, default None
 |          prove a window type, see the notes below
 |      axis : int, default 0
 |      
 |      Returns
 |      -------
 |      a Window sub-classed for the particular operation
 |      
 |      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`).
 |      
 |      The recognized window 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)
 |      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
 |  
 |  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, v, 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 `v` were inserted before the indices, the
 |      order of `self` would be preserved.
 |      
 |      Parameters
 |      ----------
 |      v : array_like
 |          Values to insert into `a`.
 |      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 `a`).
 |      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 `v`.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |      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.searchsorted([1, 2], side='right', sorter=[0, 2, 1])
 |      array([1, 3])
 |  
 |  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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 datetools 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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      skew : scalar or Series (if level specified)
 |  
 |  sort(self, axis=0, ascending=True, kind='quicksort', na_position='last', inplace=True)
 |      DEPRECATED: use :meth:`Series.sort_values(inplace=True)` for INPLACE
 |      sorting
 |      
 |      Sort values and index labels by value. This is an inplace sort by
 |      default.  Series.order is the equivalent but returns a new Series.
 |      
 |      Parameters
 |      ----------
 |      axis : int (can only be zero)
 |      ascending : boolean, default True
 |          Sort ascending. Passing False sorts descending
 |      kind : {'mergesort', 'quicksort', 'heapsort'}, default 'quicksort'
 |          Choice of sorting algorithm. See np.sort for more
 |          information. 'mergesort' is the only stable algorithm
 |      na_position : {'first', 'last'} (optional, default='last')
 |          'first' puts NaNs at the beginning
 |          'last' puts NaNs at the end
 |      inplace : boolean, default True
 |          Do operation in place.
 |      
 |      See Also
 |      --------
 |      Series.sort_values
 |  
 |  sort_index(self, axis=0, level=None, ascending=True, inplace=False, 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
 |          if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `first` puts NaNs at the beginning, `last` puts NaNs at the end
 |      sort_remaining : bool
 |          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
 |      ----------
 |      by : string name or list of names which refer to the axis items
 |      axis : index to direct sorting
 |      ascending : bool or list of bool
 |           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
 |           if True, perform operation in-place
 |      kind : {`quicksort`, `mergesort`, `heapsort`}
 |           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'}
 |           `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)
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      Returns
 |      -------
 |      sum : scalar or Series (if level specified)
 |  
 |  swaplevel(self, i, j, 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
 |  
 |  take(self, indices, axis=0, convert=True, is_copy=False)
 |      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, index=True, sep=',', na_rep='', float_format=None, header=False, index_label=None, mode='w', nanRep=None, encoding=None, date_format=None, decimal='.')
 |      Write Series to a comma-separated values (csv) file
 |      
 |      Parameters
 |      ----------
 |      path : string file path or file handle / StringIO. 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_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
 |  
 |  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
 |  
 |  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
 |      one  a   1.
 |      one  b   2.
 |      two  a   3.
 |      two  b   4.
 |      
 |      >>> s.unstack(level=-1)
 |           a   b
 |      one  1.  2.
 |      two  3.  4.
 |      
 |      >>> s.unstack(level=0)
 |         one  two
 |      a  1.   2.
 |      b  3.   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 data. If None, will attempt to use
 |          everything, then use only numeric data
 |      
 |      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:
 |  
 |  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
 |  
 |  is_time_series
 |  
 |  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-01T00:00:00.000000000-0500',
 |             '2013-01-02T00:00:00.000000000-0500',
 |             '2013-01-03T00:00:00.000000000-0500'], 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.tseries.common.CombinedDatetimelikeProperties'>
 |      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.tools.plotting.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)
 |      return the transpose, which is by definition self
 |  
 |  unique(self)
 |      Return array of unique values in the object. Significantly faster than
 |      numpy.unique. Includes NA values.
 |      
 |      Returns
 |      -------
 |      uniques : ndarray
 |  
 |  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
 |  
 |  flags
 |      return the ndarray.flags for the underlying data
 |  
 |  hasnans
 |  
 |  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
 |  
 |  __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.
 |      
 |      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)
 |      Convert all TimeSeries inside to specified frequency using DateOffset
 |      objects. Optionally provide fill method to pad/backfill missing values.
 |      
 |      Parameters
 |      ----------
 |      freq : DateOffset object, or string
 |      method : {'backfill', 'bfill', 'pad', 'ffill', 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 method
 |      how : {'start', 'end'}, default end
 |          For PeriodIndex only, see PeriodIndex.asfreq
 |      normalize : bool, default False
 |          Whether to reset output index to midnight
 |      
 |      Returns
 |      -------
 |      converted : type of caller
 |  
 |  astype(self, dtype, copy=True, raise_on_error=True, **kwargs)
 |      Cast object to input numpy.dtype
 |      Return a copy when copy = True (be really careful with this!)
 |      
 |      Parameters
 |      ----------
 |      dtype : numpy.dtype or Python type
 |      raise_on_error : raise on invalid input
 |      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 NDFrame.fillna(method='bfill')
 |  
 |  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, out=None, axis=None)
 |      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)
 |      Compute NDFrame with "consolidated" internals (data of each dtype
 |      grouped together in a single ndarray). Mainly an internal API function,
 |      but available here to the savvy user
 |      
 |      Parameters
 |      ----------
 |      inplace : boolean, default False
 |          If False return new object, otherwise modify existing object
 |      
 |      Returns
 |      -------
 |      consolidated : type of caller
 |  
 |  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 object
 |      
 |      Parameters
 |      ----------
 |      deep : boolean or string, default True
 |          Make a deep copy, i.e. also copy data
 |      
 |      Returns
 |      -------
 |      copy : type of caller
 |  
 |  describe(self, percentiles=None, include=None, exclude=None)
 |      Generate various summary statistics, excluding NaN values.
 |      
 |      Parameters
 |      ----------
 |      percentiles : array-like, optional
 |          The percentiles to include in the output. Should all
 |          be in the interval [0, 1]. By default `percentiles` is
 |          [.25, .5, .75], returning the 25th, 50th, and 75th percentiles.
 |      include, exclude : list-like, 'all', or None (default)
 |          Specify the form of the returned result. Either:
 |      
 |          - None to both (default). The result will include only
 |            numeric-typed columns or, if none are, only categorical columns.
 |          - A list of dtypes or strings to be included/excluded.
 |            To select all numeric types use numpy numpy.number. To select
 |            categorical objects use type object. See also the select_dtypes
 |            documentation. eg. df.describe(include=['O'])
 |          - If include is the string 'all', the output column-set will
 |            match the input one.
 |      
 |      Returns
 |      -------
 |      summary: NDFrame of summary statistics
 |      
 |      Notes
 |      -----
 |      The output DataFrame index depends on the requested dtypes:
 |      
 |      For numeric dtypes, it will include: count, mean, std, min,
 |      max, and lower, 50, and upper percentiles.
 |      
 |      For object dtypes (e.g. timestamps or strings), the index
 |      will include the count, unique, most common, and frequency of the
 |      most common. Timestamps also include the first and last items.
 |      
 |      For mixed dtypes, the index will be the union of the corresponding
 |      output types. Non-applicable entries will be filled with NaN.
 |      Note that mixed-dtype outputs can only be returned from mixed-dtype
 |      inputs and appropriate use of the include/exclude arguments.
 |      
 |      If multiple values have the highest count, then the
 |      `count` and `most common` pair will be arbitrarily chosen from
 |      among those with the highest count.
 |      
 |      The include, exclude arguments are ignored for Series.
 |      
 |      See Also
 |      --------
 |      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 NDFrame.fillna(method='ffill')
 |  
 |  filter(self, items=None, like=None, regex=None, axis=None)
 |      Restrict the info axis to set of items or wildcard
 |      
 |      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 None
 |          The axis to filter on. By default this is the info axis. The "info
 |          axis" is the axis that is used when indexing with ``[]``. For
 |          example, ``df = DataFrame({'a': [1, 2, 3, 4]]}); df['a']``. So,
 |          the ``DataFrame`` columns are the info axis.
 |      
 |      Notes
 |      -----
 |      Arguments are mutually exclusive, but this is not checked for
 |  
 |  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)
 |      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 / list of functions, dict, Series, or tuple /
 |          list of column names.
 |          Called on each element of the object index to determine the groups.
 |          If a dict or Series is passed, the Series or dict VALUES will be
 |          used to determine the groups
 |      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', 'pchip'}
 |      
 |          * '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', and 'pchip' are all
 |            wrappers around the scipy interpolation methods of similar
 |            names. These use the actual numerical values of the index. See
 |            the scipy documentation for more on their behavior
 |            `here <http://docs.scipy.org/doc/scipy/reference/interpolate.html#univariate-interpolation>`__  # noqa
 |            `and here <http://docs.scipy.org/doc/scipy/reference/tutorial/interpolate.html>`__  # noqa
 |      
 |      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.
 |      limit_direction : {'forward', 'backward', 'both'}, defaults to '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
 |  
 |  iterkv(self, *args, **kwargs)
 |      iteritems alias used to get around 2to3. Deprecated
 |  
 |  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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  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 scaler 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)
 |      Convenience method for frequency conversion and resampling of regular
 |      time-series data.
 |      
 |      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
 |      
 |      
 |      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
 |      2000-01-01 00:00:30   NaN
 |      2000-01-01 00:01:00     1
 |      2000-01-01 00:01:30   NaN
 |      2000-01-01 00:02:00     2
 |      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
 |  
 |  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)
 |      Squeeze length 1 dimensions.
 |  
 |  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)
 |      Activate the HDFStore.
 |      
 |      Parameters
 |      ----------
 |      path_or_buf : the path (string) or HDFStore object
 |      key : string
 |          indentifier for the group in the store
 |      mode : optional, {'a', 'w', 'r', 'r+'}, default 'a'
 |      
 |        ``'r'``
 |            Read-only; no data can be modified.
 |        ``'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
 |      complevel : int, 1-9, default 0
 |          If a complib is specified compression will be applied
 |          where possible
 |      complib : {'zlib', 'bzip2', 'lzo', 'blosc', None}, default None
 |          If complevel is > 0 apply compression to objects written
 |          in the store wherever possible
 |      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='epoch', double_precision=10, force_ascii=True, date_unit='ms', default_handler=None)
 |      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
 |      
 |      date_format : {'epoch', 'iso'}
 |          Type of date conversion. `epoch` = epoch milliseconds,
 |          `iso`` = ISO8601, 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.
 |      
 |      Returns
 |      -------
 |      same type as input object with filtered info axis
 |  
 |  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)
 |      Pickle (serialize) object to input file path.
 |      
 |      Parameters
 |      ----------
 |      path : string
 |          File path
 |  
 |  to_sql(self, name, con, flavor='sqlite', 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', 'mysql'}, default 'sqlite'
 |          The flavor of SQL to use. Ignored when using SQLAlchemy engine.
 |          'mysql' is deprecated and will be removed in future versions, but
 |          it will be further supported through SQLAlchemy engines.
 |      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
 |      dates.
 |      
 |      Parameters
 |      ----------
 |      before : date
 |          Truncate before date
 |      after : date
 |          Truncate after date
 |      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 datetools 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 or array
 |      other : scalar or NDFrame
 |      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
 |  
 |  xs(self, key, axis=0, level=None, copy=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.
 |      copy : boolean [deprecated]
 |          Whether to make a copy of the data
 |      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()
 |  
 |  empty
 |      True if NDFrame is entirely empty [no items], meaning any of the
 |      axes are of length 0.
 |      
 |      Notes
 |      -----
 |      If NDFrame contains only NaNs, it is still not considered empty. See
 |      the example below.
 |      
 |      Examples
 |      --------
 |      An example of an actual empty DataFrame. Notice the index is empty:
 |      
 |      >>> df_empty = pd.DataFrame({'A' : []})
 |      >>> df_empty
 |      Empty DataFrame
 |      Columns: [A]
 |      Index: []
 |      >>> df_empty.empty
 |      True
 |      
 |      If we only have NaNs in our DataFrame, it is not considered empty! We
 |      will need to drop the NaNs to make the DataFrame empty:
 |      
 |      >>> df = pd.DataFrame({'A' : [np.nan]})
 |      >>> df
 |          A
 |      0 NaN
 |      >>> df.empty
 |      False
 |      >>> df.dropna().empty
 |      True
 |      
 |      See also
 |      --------
 |      pandas.Series.dropna
 |      pandas.DataFrame.dropna
 |  
 |  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.
 |      
 |      ``.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.
 |      
 |      ``.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.

In [56]:

    

dir(frame)


    

    
Out[56]:





['T',
 '_AXIS_ALIASES',
 '_AXIS_IALIASES',
 '_AXIS_LEN',
 '_AXIS_NAMES',
 '_AXIS_NUMBERS',
 '_AXIS_ORDERS',
 '_AXIS_REVERSED',
 '_AXIS_SLICEMAP',
 '__abs__',
 '__add__',
 '__and__',
 '__array__',
 '__array_wrap__',
 '__bool__',
 '__bytes__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dict__',
 '__dir__',
 '__div__',
 '__doc__',
 '__eq__',
 '__finalize__',
 '__floordiv__',
 '__format__',
 '__ge__',
 '__getattr__',
 '__getattribute__',
 '__getitem__',
 '__getstate__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__invert__',
 '__ipow__',
 '__isub__',
 '__iter__',
 '__itruediv__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__module__',
 '__mul__',
 '__ne__',
 '__neg__',
 '__new__',
 '__nonzero__',
 '__or__',
 '__pow__',
 '__radd__',
 '__rand__',
 '__rdiv__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rfloordiv__',
 '__rmod__',
 '__rmul__',
 '__ror__',
 '__round__',
 '__rpow__',
 '__rsub__',
 '__rtruediv__',
 '__rxor__',
 '__setattr__',
 '__setitem__',
 '__setstate__',
 '__sizeof__',
 '__str__',
 '__sub__',
 '__subclasshook__',
 '__truediv__',
 '__unicode__',
 '__weakref__',
 '__xor__',
 '_accessors',
 '_add_numeric_operations',
 '_add_series_only_operations',
 '_add_series_or_dataframe_operations',
 '_agg_by_level',
 '_align_frame',
 '_align_series',
 '_apply_broadcast',
 '_apply_empty_result',
 '_apply_raw',
 '_apply_standard',
 '_at',
 '_box_col_values',
 '_box_item_values',
 '_check_inplace_setting',
 '_check_is_chained_assignment_possible',
 '_check_percentile',
 '_check_setitem_copy',
 '_clear_item_cache',
 '_combine_const',
 '_combine_frame',
 '_combine_match_columns',
 '_combine_match_index',
 '_combine_series',
 '_combine_series_infer',
 '_compare_frame',
 '_compare_frame_evaluate',
 '_consolidate_inplace',
 '_construct_axes_dict',
 '_construct_axes_dict_for_slice',
 '_construct_axes_dict_from',
 '_construct_axes_from_arguments',
 '_constructor',
 '_constructor_expanddim',
 '_constructor_sliced',
 '_convert',
 '_count_level',
 '_create_indexer',
 '_dir_additions',
 '_dir_deletions',
 '_ensure_valid_index',
 '_expand_axes',
 '_flex_compare_frame',
 '_from_arrays',
 '_from_axes',
 '_get_agg_axis',
 '_get_axis',
 '_get_axis_name',
 '_get_axis_number',
 '_get_axis_resolvers',
 '_get_block_manager_axis',
 '_get_bool_data',
 '_get_cacher',
 '_get_index_resolvers',
 '_get_item_cache',
 '_get_numeric_data',
 '_get_values',
 '_getitem_array',
 '_getitem_column',
 '_getitem_frame',
 '_getitem_multilevel',
 '_getitem_slice',
 '_iat',
 '_iget_item_cache',
 '_iloc',
 '_indexed_same',
 '_info_axis',
 '_info_axis_name',
 '_info_axis_number',
 '_info_repr',
 '_init_dict',
 '_init_mgr',
 '_init_ndarray',
 '_internal_names',
 '_internal_names_set',
 '_is_cached',
 '_is_datelike_mixed_type',
 '_is_mixed_type',
 '_is_numeric_mixed_type',
 '_is_view',
 '_ix',
 '_ixs',
 '_join_compat',
 '_loc',
 '_maybe_cache_changed',
 '_maybe_update_cacher',
 '_metadata',
 '_needs_reindex_multi',
 '_nsorted',
 '_protect_consolidate',
 '_reduce',
 '_reindex_axes',
 '_reindex_axis',
 '_reindex_columns',
 '_reindex_index',
 '_reindex_multi',
 '_reindex_with_indexers',
 '_repr_fits_horizontal_',
 '_repr_fits_vertical_',
 '_repr_html_',
 '_repr_latex_',
 '_reset_cache',
 '_reset_cacher',
 '_sanitize_column',
 '_series',
 '_set_as_cached',
 '_set_axis',
 '_set_axis_name',
 '_set_is_copy',
 '_set_item',
 '_setitem_array',
 '_setitem_frame',
 '_setitem_slice',
 '_setup_axes',
 '_slice',
 '_stat_axis',
 '_stat_axis_name',
 '_stat_axis_number',
 '_typ',
 '_unpickle_frame_compat',
 '_unpickle_matrix_compat',
 '_update_inplace',
 '_validate_dtype',
 '_values',
 '_xs',
 'abs',
 'add',
 'add_prefix',
 'add_suffix',
 'align',
 'all',
 'any',
 'append',
 'apply',
 'applymap',
 'as_blocks',
 'as_matrix',
 'asfreq',
 'assign',
 'astype',
 'at',
 'at_time',
 'axes',
 'between_time',
 'bfill',
 'blocks',
 'bool',
 'boxplot',
 'clip',
 'clip_lower',
 'clip_upper',
 'columns',
 'combine',
 'combineAdd',
 'combineMult',
 'combine_first',
 'compound',
 'consolidate',
 'convert_objects',
 'copy',
 'corr',
 'corrwith',
 'count',
 'cov',
 'cummax',
 'cummin',
 'cumprod',
 'cumsum',
 'describe',
 'diff',
 'div',
 'divide',
 'dot',
 'drop',
 'drop_duplicates',
 'dropna',
 'dtypes',
 'duplicated',
 'empty',
 'eq',
 'equals',
 'eval',
 'ewm',
 'expanding',
 'ffill',
 'fillna',
 'filter',
 'first',
 'first_valid_index',
 'floordiv',
 'from_csv',
 'from_dict',
 'from_items',
 'from_records',
 'ftypes',
 'ge',
 'get',
 'get_dtype_counts',
 'get_ftype_counts',
 'get_value',
 'get_values',
 'groupby',
 'gt',
 'head',
 'hist',
 'iat',
 'icol',
 'idxmax',
 'idxmin',
 'iget_value',
 'iloc',
 'index',
 'info',
 'insert',
 'interpolate',
 'irow',
 'is_copy',
 'isin',
 'isnull',
 'items',
 'iteritems',
 'iterkv',
 'iterrows',
 'itertuples',
 'ix',
 'join',
 'keys',
 'kurt',
 'kurtosis',
 'last',
 'last_valid_index',
 'le',
 'loc',
 'lookup',
 'lt',
 'mad',
 'mask',
 'max',
 'mean',
 'median',
 'memory_usage',
 'merge',
 'min',
 'mod',
 'mode',
 'mul',
 'multiply',
 'ndim',
 'ne',
 'nlargest',
 'notnull',
 'nsmallest',
 'pct_change',
 'pipe',
 'pivot',
 'pivot_table',
 'plot',
 'pop',
 'pow',
 'prod',
 'product',
 'quantile',
 'query',
 'radd',
 'rank',
 'rdiv',
 'reindex',
 'reindex_axis',
 'reindex_like',
 'rename',
 'rename_axis',
 'reorder_levels',
 'replace',
 'resample',
 'reset_index',
 'rfloordiv',
 'rmod',
 'rmul',
 'rolling',
 'round',
 'rpow',
 'rsub',
 'rtruediv',
 'sample',
 'select',
 'select_dtypes',
 'sem',
 'set_axis',
 'set_index',
 'set_value',
 'shape',
 'shift',
 'size',
 'skew',
 'slice_shift',
 'sort',
 'sort_index',
 'sort_values',
 'sortlevel',
 'squeeze',
 'stack',
 'state',
 'std',
 'style',
 'sub',
 'subtract',
 'sum',
 'swapaxes',
 'swaplevel',
 'tail',
 'take',
 'to_clipboard',
 'to_csv',
 'to_dense',
 'to_dict',
 'to_excel',
 'to_gbq',
 'to_hdf',
 'to_html',
 'to_json',
 'to_latex',
 'to_msgpack',
 'to_panel',
 'to_period',
 'to_pickle',
 'to_records',
 'to_sparse',
 'to_sql',
 'to_stata',
 'to_string',
 'to_timestamp',
 'to_wide',
 'to_xarray',
 'transpose',
 'truediv',
 'truncate',
 'tshift',
 'tz_convert',
 'tz_localize',
 'unstack',
 'update',
 'values',
 'var',
 'where',
 'xs',
 'year']

In [61]:

    

frame.ix[3]


    

    
Out[61]:





state    Nevada
year       2001
Name: 3, dtype: object