DataFrame

    def _constructor(self):

## Initialize

    def __init__(self, data=None, index=None, columns=None, dtype=None,

    def _init_dict(self, data, index, columns, dtype=None):

    def _init_ndarray(self, values, index, columns, dtype=None,



## Properties

    def axes(self):

    def shape(self):


# Used by __unicode__

    def _repr_fits_vertical_(self):

    def _repr_fits_horizontal_(self, ignore_width=False):

    def _info_repr(self):

    def __unicode__(self):



    def _repr_html_(self):


## Iterators

    def iteritems(self):

    def iterrows(self):

    def itertuples(self, index=True):


    def __len__(self):


## dot product (matrix multiplication)

    def dot(self, other):

## alt create from a dict

    def from_dict(cls, data, orient='columns', dtype=None):

    def to_dict(self, outtype='dict'):

## to google big table?

    def to_gbq(self, destination_table, project_id=None, chunksize=10000,

    def from_records(cls, data, index=None, exclude=None, columns=None,

    def to_records(self, index=True, convert_datetime64=True):

    def from_items(cls, items, columns=None, orient='columns'):

    def _from_arrays(cls, arrays, columns, index, dtype=None):

## from CSV path or file obj

    def from_csv(cls, path, header=0, sep=',', index_col=0,

    def to_sparse(self, fill_value=None, kind='block'):
                               default_kind=kind,
                               default_fill_value=fill_value)

    def to_panel(self):

## Output various external formats

    def to_csv(self, path_or_buf=None, sep=",", na_rep='', float_format=None,
            defaults to csv.QUOTE_MINIMAL

    def to_excel(self, excel_writer, sheet_name='Sheet1', na_rep='',

    def to_stata(

    def to_string(self, buf=None, columns=None, col_space=None, colSpace=None,

    def to_html(self, buf=None, columns=None, col_space=None, colSpace=None,

    def to_latex(self, buf=None, columns=None, col_space=None, colSpace=None,

## display a few stats about dataframe

    def info(self, verbose=None, buf=None, max_cols=None):

        def _verbose_repr():

        def _non_verbose_repr():


## 'rotate' the dataframe

    def transpose(self):

    def _unpickle_frame_compat(self, state):  # pragma: no cover
    def _unpickle_matrix_compat(self, state):  # pragma: no cover


    def get_value(self, index, col, takeable=False):
    def set_value(self, index, col, value, takeable=False):

    def irow(self, i, copy=False):
    def icol(self, i):


    def _ixs(self, i, axis=0):

    def iget_value(self, i, j):

## Various ways to item, depending on what `key` we got

    def __getitem__(self, key):

    def _getitem_column(self, key):

    def _getitem_slice(self, key):

    def _getitem_array(self, key):

    def _getitem_multilevel(self, key):

    def _getitem_frame(self, key):

## query the frame based on text expression `expr`

    def query(self, expr, **kwargs):

    def eval(self, expr, **kwargs):

    def select_dtypes(self, include=None, exclude=None):

        def is_dtype_instance_mapper(column, dtype):

    def _box_item_values(self, key, values):

    def _box_col_values(self, values, items):

## setitem and related helper methods

    def __setitem__(self, key, value):

    def _setitem_slice(self, key, value):

    def _setitem_array(self, key, value):

    def _setitem_frame(self, key, value):

    def _ensure_valid_index(self, value):

    def _set_item(self, key, value):



    def insert(self, loc, column, value, allow_duplicates=False):

    def _sanitize_column(self, key, value):

        def reindexer(value):

    def _series(self):

    def lookup(self, row_labels, col_labels):


## Reindex and helper methods

    def _reindex_axes(self, axes, level, limit, method, fill_value, copy):

    def _reindex_index(self, new_index, method, copy, level, fill_value=NA,

    def _reindex_columns(self, new_columns, copy, level, fill_value=NA,

    def _reindex_multi(self, axes, copy, fill_value):

    def reindex(self, index=None, columns=None, **kwargs):

    def reindex_axis(self, labels, axis=0, method=None, level=None, copy=True,



    def rename(self, index=None, columns=None, **kwargs):

    def set_index(self, keys, drop=True, append=False, inplace=False,

    def reset_index(self, level=None, drop=False, inplace=False, col_level=0,
            default

        def _maybe_casted_values(index, labels=None):

## drop columns (with none values?); drop duplicates

    def dropna(self, axis=0, how='any', thresh=None, subset=None,

    def drop_duplicates(self, subset=None, take_last=False, inplace=False):
            default use all of the columns

    def duplicated(self, subset=None, take_last=False):
            default use all of the columns

        def _m8_to_i8(x):

## SORTING

    def sort(self, columns=None, axis=0, ascending=True,

    def sort_index(self, axis=0, by=None, ascending=True, inplace=False,

                def trans(v):

    def sortlevel(self, level=0, axis=0, ascending=True,

    def swaplevel(self, i, j, axis=0):

    def reorder_levels(self, order, axis=0):


## COMBINE and helper methods

    def _combine_frame(self, other, func, fill_value=None, level=None):

    def _combine_series(self, other, func, fill_value=None, axis=None,

    def _combine_series_infer(self, other, func, level=None, fill_value=None):

    def _combine_match_index(self, other, func, level=None, fill_value=None):

    def _combine_match_columns(self, other, func, level=None, fill_value=None):

    def _combine_const(self, other, func, raise_on_error=True):



    def _compare_frame_evaluate(self, other, func, str_rep):

            def _compare(a, b):

            def _compare(a, b):

    def _compare_frame(self, other, func, str_rep):

    def _flex_compare_frame(self, other, func, str_rep, level):

    def combine(self, other, func, fill_value=None, overwrite=True):

    def combine_first(self, other):

        def combiner(x, y, needs_i8_conversion=False):

    def update(self, other, join='left', overwrite=True, filter_func=None,

    def first_valid_index(self):

    def last_valid_index(self):

    def pivot(self, index=None, columns=None, values=None):

    def stack(self, level=-1, dropna=True):

    def unstack(self, level=-1):

    def diff(self, periods=1):

    def apply(self, func, axis=0, broadcast=False, raw=False, reduce=None,

    def _apply_empty_result(self, func, axis, reduce, *args, **kwds):

    def _apply_raw(self, func, axis):

    def _apply_standard(self, func, axis, ignore_failures=False, reduce=True):

    def _apply_broadcast(self, func, axis):

    def applymap(self, func):

        def infer(x):

    def append(self, other, ignore_index=False, verify_integrity=False):

    def join(self, other, on=None, how='left', lsuffix='', rsuffix='',

    def _join_compat(self, other, on=None, how='left', lsuffix='', rsuffix='',

    def merge(self, right, how='inner', on=None, left_on=None, right_on=None,

    def corr(self, method='pearson', min_periods=1):

    def cov(self, min_periods=None):

    def corrwith(self, other, axis=0, drop=False):

    def count(self, axis=0, level=None, numeric_only=False):

    def _count_level(self, level, axis=0, numeric_only=False):

    def any(self, axis=None, bool_only=None, skipna=True, level=None,

    def all(self, axis=None, bool_only=None, skipna=True, level=None,

    def _reduce(self, op, axis=0, skipna=True, numeric_only=None,

    def idxmin(self, axis=0, skipna=True):

    def idxmax(self, axis=0, skipna=True):

    def _get_agg_axis(self, axis_num):

    def mode(self, axis=0, numeric_only=False):

    def quantile(self, q=0.5, axis=0, numeric_only=True):

        def f(arr, per):

    def rank(self, axis=0, numeric_only=None, method='average',

    def to_timestamp(self, freq=None, how='start', axis=0, copy=True):

    def to_period(self, freq=None, axis=0, copy=True):

    def isin(self, values):

    def combineAdd(self, other):

    def combineMult(self, other):


def _arrays_to_mgr(arrays, arr_names, index, columns, dtype=None):


def extract_index(data):

def _prep_ndarray(values, copy=True):
        def convert(v):

def _to_arrays(data, columns, coerce_float=False, dtype=None):

def _masked_rec_array_to_mgr(data, index, columns, dtype, copy):

def _reorder_arrays(arrays, arr_columns, columns):

def _list_to_arrays(data, columns, coerce_float=False, dtype=None):

def _list_of_series_to_arrays(data, columns, coerce_float=False, dtype=None):

def _list_of_dict_to_arrays(data, columns, coerce_float=False, dtype=None):

def _convert_object_array(content, columns, coerce_float=False, dtype=None):
    def convert(arr):

def _get_names_from_index(data):

def _homogenize(data, index, dtype=None):
def _from_nested_dict(data):

def _put_str(s, space):

def boxplot(self, column=None, by=None, ax=None, fontsize=None,