### Navigation

- index
- modules |
- next |
- previous |
- pandas 0.13.1 documentation »

# API Reference

## Input/Output

### Pickling

`read_pickle`(path) | Load pickled pandas object (or any other pickled object) from the specified

### Flat File

`read_table`(filepath_or_buffer[, sep, ...]) | Read general delimited file into DataFrame
`read_csv`(filepath_or_buffer[, sep, dialect, ...]) | Read CSV (comma-separated) file into DataFrame
`read_fwf`(filepath_or_buffer[, colspecs, widths]) | Read a table of fixed-width formatted lines into DataFrame

### Clipboard

`read_clipboard`(**kwargs) | Read text from clipboard and pass to read_table.

### Excel

`read_excel`(io, sheetname, **kwds) | Read an Excel table into a pandas DataFrame
`ExcelFile.parse`(sheetname[, header, ...]) | Read an Excel table into DataFrame

### JSON

`read_json`([path_or_buf, orient, typ, dtype, ...]) | Convert a JSON string to pandas object

### HTML

`read_html`(io[, match, flavor, header, ...]) | Read HTML tables into a `list` of `DataFrame` objects.

### HDFStore: PyTables (HDF5)

`read_hdf`(path_or_buf, key, **kwargs) | read from the store, close it if we opened it
`HDFStore.put`(key, value[, format, append]) | Store object in HDFStore
`HDFStore.append`(key, value[, format, ...]) | Append to Table in file. Node must already exist and be Table
`HDFStore.get`(key) | Retrieve pandas object stored in file
`HDFStore.select`(key[, where, start, stop, ...]) | Retrieve pandas object stored in file, optionally based on where

### SQL

`read_sql`(sql, con[, index_col, ...]) | Returns a DataFrame corresponding to the result set of the query

`read_frame`(sql, con[, index_col, ...]) | Returns a DataFrame corresponding to the result set of the query
`write_frame`(frame, name, con[, flavor, ...]) | Write records stored in a DataFrame to a SQL database.

### Google BigQuery

`read_gbq`(query[, project_id, ...]) | Load data from Google BigQuery.
`to_gbq`(dataframe, destination_table[, ...]) | Write a DataFrame to a Google BigQuery table.

### STATA

`read_stata`(filepath_or_buffer[, ...]) | Read Stata file into DataFrame

`StataReader.data`([convert_dates, ...]) | Reads observations from Stata file, converting them into a dataframe
`StataReader.data_label`() | Returns data label of Stata file
`StataReader.value_labels`() | Returns a dict, associating each variable name a dict, associating
`StataReader.variable_labels`() | Returns variable labels as a dict, associating each variable name
`StataWriter.write_file`() |

## General functions

### Data manipulations

`melt`(frame[, id_vars, value_vars, var_name, ...]) | “Unpivots” a DataFrame from wide format to long format, optionally leaving
`pivot_table`(data[, values, rows, cols, ...]) | Create a spreadsheet-style pivot table as a DataFrame. The levels in the
`crosstab`(rows, cols[, values, rownames, ...]) | Compute a simple cross-tabulation of two (or more) factors.
`cut`(x, bins[, right, labels, retbins, ...]) | Return indices of half-open bins to which each value of x belongs.
`qcut`(x, q[, labels, retbins, precision]) | Quantile-based discretization function.
`merge`(left, right[, how, on, left_on, ...]) | Merge DataFrame objects by performing a database-style join operation by
`concat`(objs[, axis, join, join_axes, ...]) | Concatenate pandas objects along a particular axis with optional set logic along the other axes.
`get_dummies`(data[, prefix, prefix_sep, dummy_na]) | Convert categorical variable into dummy/indicator variables

### Top-level missing data

`isnull`(obj) | Detect missing values (NaN in numeric arrays, None/NaN in object arrays)
`notnull`(obj) | Replacement for numpy.isfinite / -numpy.isnan which is suitable for use on object arrays.

### Top-level dealing with datetimes

`to_datetime`(arg[, errors, dayfirst, utc, ...]) | Convert argument to datetime
`to_timedelta`(arg[, box, unit]) | Convert argument to timedelta
`date_range`([start, end, periods, freq, tz, ...]) | Return a fixed frequency datetime index, with day (calendar) as the default
`bdate_range`([start, end, periods, freq, tz, ...]) | Return a fixed frequency datetime index, with business day as the default
`period_range`([start, end, periods, freq, name]) | Return a fixed frequency datetime index, with day (calendar) as the default

### Top-level evaluation

`eval`(expr[, parser, engine, truediv, ...]) | Evaluate a Python expression as a string using various backends.

### Standard moving window functions

`rolling_count`(arg, window[, freq, center, ...]) | Rolling count of number of non-NaN observations inside provided window.
`rolling_sum`(arg, window[, min_periods, ...]) | Moving sum
`rolling_mean`(arg, window[, min_periods, ...]) | Moving mean
`rolling_median`(arg, window[, min_periods, ...]) | O(N log(window)) implementation using skip list
`rolling_var`(arg, window[, min_periods, ...]) | Unbiased moving variance
`rolling_std`(arg, window[, min_periods, ...]) | Unbiased moving standard deviation
`rolling_min`(arg, window[, min_periods, ...]) | Moving min of 1d array of dtype=float64 along axis=0 ignoring NaNs.
`rolling_max`(arg, window[, min_periods, ...]) | Moving max of 1d array of dtype=float64 along axis=0 ignoring NaNs.
`rolling_corr`(arg1, arg2, window[, ...]) | Moving sample correlation
`rolling_corr_pairwise`(df, window[, min_periods]) | Computes pairwise rolling correlation matrices as Panel whose items are
`rolling_cov`(arg1, arg2, window[, ...]) | Unbiased moving covariance
`rolling_skew`(arg, window[, min_periods, ...]) | Unbiased moving skewness
`rolling_kurt`(arg, window[, min_periods, ...]) | Unbiased moving kurtosis
`rolling_apply`(arg, window, func[, ...]) | Generic moving function application
`rolling_quantile`(arg, window, quantile[, ...]) | Moving quantile
`rolling_window`(arg[, window, win_type, ...]) | Applies a moving window of type `window_type` and size `window` on the data.

### Standard expanding window functions

`expanding_count`(arg[, freq, center, time_rule]) | Expanding count of number of non-NaN observations.
`expanding_sum`(arg[, min_periods, freq, ...]) | Expanding sum
`expanding_mean`(arg[, min_periods, freq, ...]) | Expanding mean
`expanding_median`(arg[, min_periods, freq, ...]) | O(N log(window)) implementation using skip list
`expanding_var`(arg[, min_periods, freq, ...]) | Unbiased expanding variance
`expanding_std`(arg[, min_periods, freq, ...]) | Unbiased expanding standard deviation
`expanding_min`(arg[, min_periods, freq, ...]) | Moving min of 1d array of dtype=float64 along axis=0 ignoring NaNs.
`expanding_max`(arg[, min_periods, freq, ...]) | Moving max of 1d array of dtype=float64 along axis=0 ignoring NaNs.
`expanding_corr`(arg1, arg2[, min_periods, ...]) | Expanding sample correlation
`expanding_corr_pairwise`(df[, min_periods]) | Computes pairwise expanding correlation matrices as Panel whose items are
`expanding_cov`(arg1, arg2[, min_periods, ...]) | Unbiased expanding covariance
`expanding_skew`(arg[, min_periods, freq, ...]) | Unbiased expanding skewness
`expanding_kurt`(arg[, min_periods, freq, ...]) | Unbiased expanding kurtosis
`expanding_apply`(arg, func[, min_periods, ...]) | Generic expanding function application
`expanding_quantile`(arg, quantile[, ...]) | Expanding quantile

### Exponentially-weighted moving window functions

`ewma`(arg[, com, span, halflife, ...]) | Exponentially-weighted moving average
`ewmstd`(arg[, com, span, halflife, ...]) | Exponentially-weighted moving std
`ewmvar`(arg[, com, span, halflife, ...]) | Exponentially-weighted moving variance
`ewmcorr`(arg1, arg2[, com, span, halflife, ...]) | Exponentially-weighted moving correlation
`ewmcov`(arg1, arg2[, com, span, halflife, ...]) | Exponentially-weighted moving covariance

## Series

### Constructor

`Series`([data, index, dtype, name, copy, ...]) | One-dimensional ndarray with axis labels (including time series).

### Attributes and underlying data

Axes
  - index: axis labels

`Series.values` | Return Series as ndarray
`Series.dtype` |
`Series.ftype` |

### Conversion

`Series.astype`(dtype[, copy, raise_on_error]) | Cast object to input numpy.dtype
`Series.copy`([deep]) | Make a copy of this object
`Series.isnull`() | Return a boolean same-sized object indicating if the values are null
`Series.notnull`() | Return a boolean same-sized object indicating if the values are

### Indexing, iteration

`Series.get`(label[, default]) | Returns value occupying requested label, default to specified missing value if not present.
`Series.at` |
`Series.iat` |
`Series.ix` |
`Series.loc` |
`Series.iloc` |
`Series.__iter__`() |
`Series.iteritems`() | Lazily iterate over (index, value) tuples

For more information on `.at`, `.iat`, `.ix`, `.loc`, and `.iloc`, see the indexing documentation.

### Binary operator functions

`Series.add`(other[, level, fill_value, axis]) | Binary operator add with support to substitute a fill_value for missing data
`Series.sub`(other[, level, fill_value, axis]) | Binary operator sub with support to substitute a fill_value for missing data
`Series.mul`(other[, level, fill_value, axis]) | Binary operator mul with support to substitute a fill_value for missing data
`Series.div`(other[, level, fill_value, axis]) | Binary operator truediv with support to substitute a fill_value for missing data
`Series.truediv`(other[, level, fill_value, axis]) | Binary operator truediv with support to substitute a fill_value for missing data
`Series.floordiv`(other[, level, fill_value, axis]) | Binary operator floordiv with support to substitute a fill_value for missing data
`Series.mod`(other[, level, fill_value, axis]) | Binary operator mod with support to substitute a fill_value for missing data
`Series.pow`(other[, level, fill_value, axis]) | Binary operator pow with support to substitute a fill_value for missing data
`Series.radd`(other[, level, fill_value, axis]) | Binary operator radd with support to substitute a fill_value for missing data
`Series.rsub`(other[, level, fill_value, axis]) | Binary operator rsub with support to substitute a fill_value for missing data
`Series.rmul`(other[, level, fill_value, axis]) | Binary operator rmul with support to substitute a fill_value for missing data
`Series.rdiv`(other[, level, fill_value, axis]) | Binary operator rtruediv with support to substitute a fill_value for missing data
`Series.rtruediv`(other[, level, fill_value, axis]) | Binary operator rtruediv with support to substitute a fill_value for missing data
`Series.rfloordiv`(other[, level, fill_value, ...]) | Binary operator rfloordiv with support to substitute a fill_value for missing data
`Series.rmod`(other[, level, fill_value, axis]) | Binary operator rmod with support to substitute a fill_value for missing data
`Series.rpow`(other[, level, fill_value, axis]) | Binary operator rpow with support to substitute a fill_value for missing data
`Series.combine`(other, func[, fill_value]) | Perform elementwise binary operation on two Series using given function
`Series.combine_first`(other) | Combine Series values, choosing the calling Series’s values
`Series.round`([decimals, out]) | Return a with each element rounded to the given number of decimals.
`Series.lt`(other) |
`Series.gt`(other) |
`Series.le`(other) |
`Series.ge`(other) |
`Series.ne`(other) |
`Series.eq`(other) |

### Function application, GroupBy

`Series.apply`(func[, convert_dtype, args]) | Invoke function on values of Series. Can be ufunc (a NumPy function
`Series.map`(arg[, na_action]) | Map values of Series using input correspondence (which can be
`Series.groupby`([by, axis, level, as_index, ...]) | Group series using mapper (dict or key function, apply given function

### Computations / Descriptive Stats

`Series.abs`() | Return an object with absolute value taken.
`Series.any`([axis, out]) | Returns True if any of the elements of a evaluate to True.
`Series.autocorr`() | Lag-1 autocorrelation
`Series.between`(left, right[, inclusive]) | Return boolean Series equivalent to left <= series <= right. NA values
`Series.clip`([lower, upper, out]) | Trim values at input threshold(s)
`Series.clip_lower`(threshold) | Return copy of the input with values below given value truncated
`Series.clip_upper`(threshold) | Return copy of input with values above given value truncated
`Series.corr`(other[, method, min_periods]) | Compute correlation with other Series, excluding missing values
`Series.count`([level]) | Return number of non-NA/null observations in the Series
`Series.cov`(other[, min_periods]) | Compute covariance with Series, excluding missing values
`Series.cummax`([axis, dtype, out, skipna]) | Return cumulative max over requested axis.
`Series.cummin`([axis, dtype, out, skipna]) | Return cumulative min over requested axis.
`Series.cumprod`([axis, dtype, out, skipna]) | Return cumulative prod over requested axis.
`Series.cumsum`([axis, dtype, out, skipna]) | Return cumulative sum over requested axis.
`Series.describe`([percentile_width]) | Generate various summary statistics of Series, excluding NaN
`Series.diff`([periods]) | 1st discrete difference of object
`Series.kurt`([axis, skipna, level, numeric_only]) | Return unbiased kurtosis over requested axis
`Series.mad`([axis, skipna, level]) | Return the mean absolute deviation of the values for the requested axis
`Series.max`([axis, skipna, level, numeric_only]) | This method returns the maximum of the values in the object.
`Series.mean`([axis, skipna, level, numeric_only]) | Return the mean of the values for the requested axis
`Series.median`([axis, skipna, level, ...]) | Return the median of the values for the requested axis
`Series.min`([axis, skipna, level, numeric_only]) | This method returns the minimum of the values in the object.
`Series.mode`() | Returns the mode(s) of the dataset.
`Series.nunique`() | Return count of unique elements in the Series
`Series.pct_change`([periods, fill_method, ...]) | Percent change over given number of periods
`Series.prod`([axis, skipna, level, numeric_only]) | Return the product of the values for the requested axis
`Series.quantile`([q]) | Return value at the given quantile, a la scoreatpercentile in
`Series.rank`([method, na_option, ascending]) | Compute data ranks (1 through n).
`Series.skew`([axis, skipna, level, numeric_only]) | Return unbiased skew over requested axis
`Series.std`([axis, skipna, level, ddof]) | Return unbiased standard deviation over requested axis
`Series.sum`([axis, skipna, level, numeric_only]) | Return the sum of the values for the requested axis
`Series.unique`() | Return array of unique values in the Series. Significantly faster than
`Series.var`([axis, skipna, level, ddof]) | Return unbiased variance over requested axis
`Series.value_counts`([normalize, sort, ...]) | Returns Series containing counts of unique values. The resulting Series

### Reindexing / Selection / Label manipulation

`Series.align`(other[, join, axis, level, ...]) | Align two object on their axes with the
`Series.drop`(labels[, axis, level, inplace]) | Return new object with labels in requested axis removed
`Series.first`(offset) | Convenience method for subsetting initial periods of time series data
`Series.head`([n]) | Returns first n rows
`Series.idxmax`([axis, out, skipna]) | Index of first occurrence of maximum of values.
`Series.idxmin`([axis, out, skipna]) | Index of first occurrence of minimum of values.
`Series.isin`(values) | Return a boolean `Series` showing whether each element
`Series.last`(offset) | Convenience method for subsetting final periods of time series data
`Series.reindex`([index]) | Conform Series to new index with optional filling logic, placing
`Series.reindex_like`(other[, method, copy, limit]) | return an object with matching indicies to myself
`Series.rename`([index]) | Alter axes input function or functions.
`Series.reset_index`([level, drop, name, inplace]) | Analogous to the `pandas.DataFrame.reset_index()` function, see
`Series.select`(crit[, axis]) | Return data corresponding to axis labels matching criteria
`Series.take`(indices[, axis, convert]) | Analogous to ndarray.take, return Series corresponding to requested
`Series.tail`([n]) | Returns last n rows
`Series.truncate`([before, after, axis, copy]) | Truncates a sorted NDFrame before and/or after some particular

### Missing data handling

`Series.dropna`([axis, inplace]) | Return Series without null values
`Series.fillna`([value, method, axis, ...]) | Fill NA/NaN values using the specified method
`Series.interpolate`([method, axis, limit, ...]) | Interpolate values according to different methods.

### Reshaping, sorting

`Series.argsort`([axis, kind, order]) | Overrides ndarray.argsort.
`Series.order`([na_last, ascending, kind]) | Sorts Series object, by value, maintaining index-value link
`Series.reorder_levels`(order) | Rearrange index levels using input order.
`Series.sort`([axis, kind, order, ascending]) | Sort values and index labels by value, in place.
`Series.sort_index`([ascending]) | Sort object by labels (along an axis)
`Series.sortlevel`([level, ascending]) | Sort Series with MultiIndex by chosen level. Data will be
`Series.swaplevel`(i, j[, copy]) | Swap levels i and j in a MultiIndex
`Series.unstack`([level]) | Unstack, a.k.a.

### Combining / joining / merging

`Series.append`(to_append[, verify_integrity]) | Concatenate two or more Series. The indexes must not overlap
`Series.replace`([to_replace, value, inplace, ...]) | Replace values given in ‘to_replace’ with ‘value’.
`Series.update`(other) | Modify Series in place using non-NA values from passed

### Time series-related

`Series.asfreq`(freq[, method, how, normalize]) | Convert all TimeSeries inside to specified frequency using DateOffset
`Series.asof`(where) | Return last good (non-NaN) value in TimeSeries if value is NaN for
`Series.shift`([periods, freq, axis]) | Shift index by desired number of periods with an optional time freq
`Series.first_valid_index`() | Return label for first non-NA/null value
`Series.last_valid_index`() | Return label for last non-NA/null value
`Series.weekday` |
`Series.resample`(rule[, how, axis, ...]) | Convenience method for frequency conversion and resampling of regular time-series data.
`Series.tz_convert`(tz[, copy]) | Convert TimeSeries to target time zone
`Series.tz_localize`(tz[, copy, infer_dst]) | Localize tz-naive TimeSeries to target time zone

### String handling

`Series.str` can be used to access the values of the series as strings and apply several methods to it. Due to implementation details the methods show up here as methods of the `StringMethods` class.

`StringMethods.cat`([others, sep, na_rep]) | Concatenate arrays of strings with given separator
`StringMethods.center`(width) | “Center” strings, filling left and right side with additional whitespace
`StringMethods.contains`(pat[, case, flags, ...]) | Check whether given pattern is contained in each string in the array
`StringMethods.count`(pat[, flags]) | Count occurrences of pattern in each string
`StringMethods.decode`(encoding[, errors]) | Decode character string to unicode using indicated encoding
`StringMethods.encode`(encoding[, errors]) | Encode character string to some other encoding using indicated encoding
`StringMethods.endswith`(pat[, na]) | Return boolean array indicating whether each string ends with passed
`StringMethods.extract`(pat[, flags]) | Find groups in each string using passed regular expression
`StringMethods.findall`(pat[, flags]) | Find all occurrences of pattern or regular expression
`StringMethods.get`(i) | Extract element from lists, tuples, or strings in each element in the array
`StringMethods.join`(sep) | Join lists contained as elements in array, a la str.join
`StringMethods.len`() | Compute length of each string in array.
`StringMethods.lower`() | Convert strings in array to lowercase
`StringMethods.lstrip`([to_strip]) | Strip whitespace (including newlines) from left side of each string in the
`StringMethods.match`(pat[, flags]) | Deprecated: Find groups in each string using passed regular expression.
`StringMethods.pad`(width[, side]) | Pad strings with whitespace
`StringMethods.repeat`(repeats) | Duplicate each string in the array by indicated number of times
`StringMethods.replace`(pat, repl[, n, case, ...]) | Replace
`StringMethods.rstrip`([to_strip]) | Strip whitespace (including newlines) from right side of each string in the
`StringMethods.slice`([start, stop, step]) | Slice substrings from each element in array
`StringMethods.slice_replace`([i, j]) | Slice substrings from each element in array
`StringMethods.split`([pat, n]) | Split each string (a la re.split) in array by given pattern, propagating NA
`StringMethods.startswith`(pat[, na]) | Return boolean array indicating whether each string starts with passed
`StringMethods.strip`([to_strip]) | Strip whitespace (including newlines) from each string in the array
`StringMethods.title`() | Convert strings to titlecased version
`StringMethods.upper`() | Convert strings in array to uppercase
`StringMethods.get_dummies`([sep]) | Split each string by sep and return a frame of dummy/indicator variables.

### Plotting

`Series.hist`([by, ax, grid, xlabelsize, ...]) | Draw histogram of the input series using matplotlib
`Series.plot`(series[, label, kind, ...]) | Plot the input series with the index on the x-axis using matplotlib

### Serialization / IO / Conversion

`Series.from_csv`(path[, sep, parse_dates, ...]) | Read delimited file into Series
`Series.to_pickle`(path) | Pickle (serialize) object to input file path
`Series.to_csv`(path[, index, sep, na_rep, ...]) | Write Series to a comma-separated values (csv) file
`Series.to_dict`() | Convert Series to {label -> value} dict
`Series.to_frame`([name]) | Convert Series to DataFrame
`Series.to_hdf`(path_or_buf, key, **kwargs) | activate the HDFStore
`Series.to_json`([path_or_buf, orient, ...]) | Convert the object to a JSON string.
`Series.to_sparse`([kind, fill_value]) | Convert Series to SparseSeries
`Series.to_string`([buf, na_rep, ...]) | Render a string representation of the Series
`Series.to_clipboard`([excel, sep]) | Attempt to write text representation of object to the system clipboard

## DataFrame

### Constructor

`DataFrame`([data, index, columns, dtype, copy]) | Two-dimensional size-mutable, potentially heterogeneous tabular data structure with labeled axes (rows and columns).

### Attributes and underlying data

Axes

> - index: row labels
> - columns: column labels

`DataFrame.as_matrix`([columns]) | Convert the frame to its Numpy-array matrix representation. Columns
`DataFrame.dtypes` | Return the dtypes in this object
`DataFrame.ftypes` | Return the ftypes (indication of sparse/dense and dtype)
`DataFrame.get_dtype_counts`() | Return the counts of dtypes in this object
`DataFrame.get_ftype_counts`() | Return the counts of ftypes in this object
`DataFrame.values` | Numpy representation of NDFrame
`DataFrame.axes` |
`DataFrame.ndim` | Number of axes / array dimensions
`DataFrame.shape` |

### Conversion

`DataFrame.astype`(dtype[, copy, raise_on_error]) | Cast object to input numpy.dtype
`DataFrame.convert_objects`([convert_dates, ...]) | Attempt to infer better dtype for object columns
`DataFrame.copy`([deep]) | Make a copy of this object
`DataFrame.isnull`() | Return a boolean same-sized object indicating if the values are null
`DataFrame.notnull`() | Return a boolean same-sized object indicating if the values are

### Indexing, iteration

`DataFrame.head`([n]) | Returns first n rows
`DataFrame.at` |
`DataFrame.iat` |
`DataFrame.ix` |
`DataFrame.loc` |
`DataFrame.iloc` |
`DataFrame.insert`(loc, column, value[, ...]) | Insert column into DataFrame at specified location.
`DataFrame.__iter__`() | Iterate over infor axis
`DataFrame.iteritems`() | Iterator over (column, series) pairs
`DataFrame.iterrows`() | Iterate over rows of DataFrame as (index, Series) pairs.
`DataFrame.itertuples`([index]) | Iterate over rows of DataFrame as tuples, with index value
`DataFrame.lookup`(row_labels, col_labels) | Label-based “fancy indexing” function for DataFrame.
`DataFrame.pop`(item) | Return item and drop from frame.
`DataFrame.tail`([n]) | Returns last n rows
`DataFrame.xs`(key[, axis, level, copy, ...]) | Returns a cross-section (row(s) or column(s)) from the Series/DataFrame.
`DataFrame.isin`(values) | Return boolean DataFrame showing whether each element in the
`DataFrame.query`(expr, **kwargs) | Query the columns of a frame with a boolean expression.

For more information on `.at`, `.iat`, `.ix`, `.loc`, and `.iloc`, see the indexing documentation.

### Binary operator functions

`DataFrame.add`(other[, axis, level, fill_value]) | Binary operator add with support to substitute a fill_value for missing data in
`DataFrame.sub`(other[, axis, level, fill_value]) | Binary operator sub with support to substitute a fill_value for missing data in
`DataFrame.mul`(other[, axis, level, fill_value]) | Binary operator mul with support to substitute a fill_value for missing data in
`DataFrame.div`(other[, axis, level, fill_value]) | Binary operator truediv with support to substitute a fill_value for missing data in
`DataFrame.truediv`(other[, axis, level, ...]) | Binary operator truediv with support to substitute a fill_value for missing data in
`DataFrame.floordiv`(other[, axis, level, ...]) | Binary operator floordiv with support to substitute a fill_value for missing data in
`DataFrame.mod`(other[, axis, level, fill_value]) | Binary operator mod with support to substitute a fill_value for missing data in
`DataFrame.pow`(other[, axis, level, fill_value]) | Binary operator pow with support to substitute a fill_value for missing data in
`DataFrame.radd`(other[, axis, level, fill_value]) | Binary operator radd with support to substitute a fill_value for missing data in
`DataFrame.rsub`(other[, axis, level, fill_value]) | Binary operator rsub with support to substitute a fill_value for missing data in
`DataFrame.rmul`(other[, axis, level, fill_value]) | Binary operator rmul with support to substitute a fill_value for missing data in
`DataFrame.rdiv`(other[, axis, level, fill_value]) | Binary operator rtruediv with support to substitute a fill_value for missing data in
`DataFrame.rtruediv`(other[, axis, level, ...]) | Binary operator rtruediv with support to substitute a fill_value for missing data in
`DataFrame.rfloordiv`(other[, axis, level, ...]) | Binary operator rfloordiv with support to substitute a fill_value for missing data in
`DataFrame.rmod`(other[, axis, level, fill_value]) | Binary operator rmod with support to substitute a fill_value for missing data in
`DataFrame.rpow`(other[, axis, level, fill_value]) | Binary operator rpow with support to substitute a fill_value for missing data in
`DataFrame.lt`(other[, axis, level]) | Wrapper for flexible comparison methods lt
`DataFrame.gt`(other[, axis, level]) | Wrapper for flexible comparison methods gt
`DataFrame.le`(other[, axis, level]) | Wrapper for flexible comparison methods le
`DataFrame.ge`(other[, axis, level]) | Wrapper for flexible comparison methods ge
`DataFrame.ne`(other[, axis, level]) | Wrapper for flexible comparison methods ne
`DataFrame.eq`(other[, axis, level]) | Wrapper for flexible comparison methods eq
`DataFrame.combine`(other, func[, fill_value, ...]) | Add two DataFrame objects and do not propagate NaN values, so if for a
`DataFrame.combineAdd`(other) | Add two DataFrame objects and do not propagate
`DataFrame.combine_first`(other) | Combine two DataFrame objects and default to non-null values in frame
`DataFrame.combineMult`(other) | Multiply two DataFrame objects and do not propagate NaN values, so if

### Function application, GroupBy

`DataFrame.apply`(func[, axis, broadcast, ...]) | Applies function along input axis of DataFrame.
`DataFrame.applymap`(func) | Apply a function to a DataFrame that is intended to operate
`DataFrame.groupby`([by, axis, level, ...]) | Group series using mapper (dict or key function, apply given function

### Computations / Descriptive Stats

`DataFrame.abs`() | Return an object with absolute value taken.
`DataFrame.any`([axis, bool_only, skipna, level]) | Return whether any element is True over requested axis.
`DataFrame.clip`([lower, upper, out]) | Trim values at input threshold(s)
`DataFrame.clip_lower`(threshold) | Return copy of the input with values below given value truncated
`DataFrame.clip_upper`(threshold) | Return copy of input with values above given value truncated
`DataFrame.corr`([method, min_periods]) | Compute pairwise correlation of columns, excluding NA/null values
`DataFrame.corrwith`(other[, axis, drop]) | Compute pairwise correlation between rows or columns of two DataFrame
`DataFrame.count`([axis, level, numeric_only]) | Return Series with number of non-NA/null observations over requested
`DataFrame.cov`([min_periods]) | Compute pairwise covariance of columns, excluding NA/null values
`DataFrame.cummax`([axis, dtype, out, skipna]) | Return cumulative max over requested axis.
`DataFrame.cummin`([axis, dtype, out, skipna]) | Return cumulative min over requested axis.
`DataFrame.cumprod`([axis, dtype, out, skipna]) | Return cumulative prod over requested axis.
`DataFrame.cumsum`([axis, dtype, out, skipna]) | Return cumulative sum over requested axis.
`DataFrame.describe`([percentile_width]) | Generate various summary statistics of each column, excluding
`DataFrame.diff`([periods]) | 1st discrete difference of object
`DataFrame.eval`(expr, **kwargs) | Evaluate an expression in the context of the calling DataFrame
`DataFrame.kurt`([axis, skipna, level, ...]) | Return unbiased kurtosis over requested axis
`DataFrame.mad`([axis, skipna, level]) | Return the mean absolute deviation of the values for the requested axis
`DataFrame.max`([axis, skipna, level, ...]) | This method returns the maximum of the values in the object.
`DataFrame.mean`([axis, skipna, level, ...]) | Return the mean of the values for the requested axis
`DataFrame.median`([axis, skipna, level, ...]) | Return the median of the values for the requested axis
`DataFrame.min`([axis, skipna, level, ...]) | This method returns the minimum of the values in the object.
`DataFrame.mode`([axis, numeric_only]) | Gets the mode of each element along the axis selected.
`DataFrame.pct_change`([periods, fill_method, ...]) | Percent change over given number of periods
`DataFrame.prod`([axis, skipna, level, ...]) | Return the product of the values for the requested axis
`DataFrame.quantile`([q, axis, numeric_only]) | Return values at the given quantile over requested axis, a la
`DataFrame.rank`([axis, numeric_only, method, ...]) | Compute numerical data ranks (1 through n) along axis.
`DataFrame.skew`([axis, skipna, level, ...]) | Return unbiased skew over requested axis
`DataFrame.sum`([axis, skipna, level, ...]) | Return the sum of the values for the requested axis
`DataFrame.std`([axis, skipna, level, ddof]) | Return unbiased standard deviation over requested axis
`DataFrame.var`([axis, skipna, level, ddof]) | Return unbiased variance over requested axis

### Reindexing / Selection / Label manipulation

`DataFrame.add_prefix`(prefix) | Concatenate prefix string with panel items names.
`DataFrame.add_suffix`(suffix) | Concatenate suffix string with panel items names
`DataFrame.align`(other[, join, axis, level, ...]) | Align two object on their axes with the
`DataFrame.drop`(labels[, axis, level, inplace]) | Return new object with labels in requested axis removed
`DataFrame.drop_duplicates`([cols, take_last, ...]) | Return DataFrame with duplicate rows removed, optionally only
`DataFrame.duplicated`([cols, take_last]) | Return boolean Series denoting duplicate rows, optionally only
`DataFrame.filter`([items, like, regex, axis]) | Restrict the info axis to set of items or wildcard
`DataFrame.first`(offset) | Convenience method for subsetting initial periods of time series data
`DataFrame.head`([n]) | Returns first n rows
`DataFrame.idxmax`([axis, skipna]) | Return index of first occurrence of maximum over requested axis.
`DataFrame.idxmin`([axis, skipna]) | Return index of first occurrence of minimum over requested axis.
`DataFrame.last`(offset) | Convenience method for subsetting final periods of time series data
`DataFrame.reindex`([index, columns]) | Conform DataFrame to new index with optional filling logic, placing
`DataFrame.reindex_axis`(labels[, axis, ...]) | Conform input object to new index with optional filling logic,
`DataFrame.reindex_like`(other[, method, ...]) | return an object with matching indicies to myself
`DataFrame.rename`([index, columns]) | Alter axes input function or functions.
`DataFrame.reset_index`([level, drop, ...]) | For DataFrame with multi-level index, return new DataFrame with
`DataFrame.select`(crit[, axis]) | Return data corresponding to axis labels matching criteria
`DataFrame.set_index`(keys[, drop, append, ...]) | Set the DataFrame index (row labels) using one or more existing
`DataFrame.tail`([n]) | Returns last n rows
`DataFrame.take`(indices[, axis, convert, is_copy]) | Analogous to ndarray.take
`DataFrame.truncate`([before, after, axis, copy]) | Truncates a sorted NDFrame before and/or after some particular

### Missing data handling

`DataFrame.dropna`([axis, how, thresh, ...]) | Return object with labels on given axis omitted where alternately any
`DataFrame.fillna`([value, method, axis, ...]) | Fill NA/NaN values using the specified method
`DataFrame.replace`([to_replace, value, ...]) | Replace values given in ‘to_replace’ with ‘value’.

### Reshaping, sorting, transposing

`DataFrame.delevel`(*args, **kwargs) |
`DataFrame.pivot`([index, columns, values]) | Reshape data (produce a “pivot” table) based on column values.
`DataFrame.reorder_levels`(order[, axis]) | Rearrange index levels using input order.
`DataFrame.sort`([columns, column, axis, ...]) | Sort DataFrame either by labels (along either axis) or by the values in
`DataFrame.sort_index`([axis, by, ascending, ...]) | Sort DataFrame either by labels (along either axis) or by the values in
`DataFrame.sortlevel`([level, axis, ...]) | Sort multilevel index by chosen axis and primary level.
`DataFrame.swaplevel`(i, j[, axis]) | Swap levels i and j in a MultiIndex on a particular axis
`DataFrame.stack`([level, dropna]) | Pivot a level of the (possibly hierarchical) column labels, returning a
`DataFrame.unstack`([level]) | Pivot a level of the (necessarily hierarchical) index labels, returning
`DataFrame.T` | Transpose index and columns
`DataFrame.to_panel`() | Transform long (stacked) format (DataFrame) into wide (3D, Panel)
`DataFrame.transpose`() | Transpose index and columns

### Combining / joining / merging

`DataFrame.append`(other[, ignore_index, ...]) | Append columns of other to end of this frame’s columns and index, returning a new object.
`DataFrame.join`(other[, on, how, lsuffix, ...]) | Join columns with other DataFrame either on index or on a key
`DataFrame.merge`(right[, how, on, left_on, ...]) | Merge DataFrame objects by performing a database-style join operation by
`DataFrame.update`(other[, join, overwrite, ...]) | Modify DataFrame in place using non-NA values from passed

### Time series-related

`DataFrame.asfreq`(freq[, method, how, normalize]) | Convert all TimeSeries inside to specified frequency using DateOffset
`DataFrame.shift`([periods, freq, axis]) | Shift index by desired number of periods with an optional time freq
`DataFrame.first_valid_index`() | Return label for first non-NA/null value
`DataFrame.last_valid_index`() | Return label for last non-NA/null value
`DataFrame.resample`(rule[, how, axis, ...]) | Convenience method for frequency conversion and resampling of regular time-series data.
`DataFrame.to_period`([freq, axis, copy]) | Convert DataFrame from DatetimeIndex to PeriodIndex with desired
`DataFrame.to_timestamp`([freq, how, axis, copy]) | Cast to DatetimeIndex of timestamps, at beginning of period
`DataFrame.tz_convert`(tz[, axis, copy]) | Convert TimeSeries to target time zone. If it is time zone naive, it
`DataFrame.tz_localize`(tz[, axis, copy, ...]) | Localize tz-naive TimeSeries to target time zone

### Plotting

`DataFrame.boxplot`([column, by, ax, ...]) | Make a box plot from DataFrame column/columns optionally grouped
`DataFrame.hist`(data[, column, by, grid, ...]) | Draw histogram of the DataFrame’s series using matplotlib / pylab.
`DataFrame.plot`([frame, x, y, subplots, ...]) | Make line, bar, or scatter plots of DataFrame series with the index on the x-axis

### Serialization / IO / Conversion

`DataFrame.from_csv`(path[, header, sep, ...]) | Read delimited file into DataFrame
`DataFrame.from_dict`(data[, orient, dtype]) | Construct DataFrame from dict of array-like or dicts
`DataFrame.from_items`(items[, columns, orient]) | Convert (key, value) pairs to DataFrame. The keys will be the axis
`DataFrame.from_records`(data[, index, ...]) | Convert structured or record ndarray to DataFrame
`DataFrame.info`([verbose, buf, max_cols]) | Concise summary of a DataFrame.
`DataFrame.to_pickle`(path) | Pickle (serialize) object to input file path
`DataFrame.to_csv`(path_or_buf[, sep, na_rep, ...]) | Write DataFrame to a comma-separated values (csv) file
`DataFrame.to_hdf`(path_or_buf, key, **kwargs) | activate the HDFStore
`DataFrame.to_dict`([outtype]) | Convert DataFrame to dictionary.
`DataFrame.to_excel`(excel_writer[, ...]) | Write DataFrame to a excel sheet
`DataFrame.to_json`([path_or_buf, orient, ...]) | Convert the object to a JSON string.
`DataFrame.to_html`([buf, columns, col_space, ...]) | Render a DataFrame as an HTML table.
`DataFrame.to_latex`([buf, columns, ...]) | Render a DataFrame to a tabular environment table.
`DataFrame.to_stata`(fname[, convert_dates, ...]) | A class for writing Stata binary dta files from array-like objects
`DataFrame.to_records`([index, convert_datetime64]) | Convert DataFrame to record array. Index will be put in the
`DataFrame.to_sparse`([fill_value, kind]) | Convert to SparseDataFrame
`DataFrame.to_string`([buf, columns, ...]) | Render a DataFrame to a console-friendly tabular output.
`DataFrame.to_clipboard`([excel, sep]) | Attempt to write text representation of object to the system clipboard

## Panel

### Constructor

`Panel`([data, items, major_axis, minor_axis, ...]) | Represents wide format panel data, stored as 3-dimensional array

### Attributes and underlying data

Axes

> - items: axis 0; each item corresponds to a DataFrame contained inside
> - major_axis: axis 1; the index (rows) of each of the DataFrames
> - minor_axis: axis 2; the columns of each of the DataFrames

`Panel.values` | Numpy representation of NDFrame
`Panel.axes` | index(es) of the NDFrame
`Panel.ndim` | Number of axes / array dimensions
`Panel.shape` | tuple of axis dimensions
`Panel.dtypes` | Return the dtypes in this object
`Panel.ftypes` | Return the ftypes (indication of sparse/dense and dtype)
`Panel.get_dtype_counts`() | Return the counts of dtypes in this object
`Panel.get_ftype_counts`() | Return the counts of ftypes in this object

### Conversion

`Panel.astype`(dtype[, copy, raise_on_error]) | Cast object to input numpy.dtype
`Panel.copy`([deep]) | Make a copy of this object
`Panel.isnull`() | Return a boolean same-sized object indicating if the values are null
`Panel.notnull`() | Return a boolean same-sized object indicating if the values are

### Getting and setting

`Panel.get_value`(*args) | Quickly retrieve single value at (item, major, minor) location
`Panel.set_value`(*args) | Quickly set single value at (item, major, minor) location

### Indexing, iteration, slicing

`Panel.at` |
`Panel.iat` |
`Panel.ix` |
`Panel.loc` |
`Panel.iloc` |
`Panel.__iter__`() | Iterate over infor axis
`Panel.iteritems`() | Iterate over (label, values) on info axis
`Panel.pop`(item) | Return item and drop from frame.
`Panel.xs`(key[, axis, copy]) | Return slice of panel along selected axis
`Panel.major_xs`(key[, copy]) | Return slice of panel along major axis
`Panel.minor_xs`(key[, copy]) | Return slice of panel along minor axis

For more information on `.at`, `.iat`, `.ix`, `.loc`, and `.iloc`, see the indexing documentation.

### Binary operator functions

`Panel.add`(other[, axis]) | Wrapper method for add
`Panel.sub`(other[, axis]) | Wrapper method for sub
`Panel.mul`(other[, axis]) | Wrapper method for mul
`Panel.div`(other[, axis]) | Wrapper method for truediv
`Panel.truediv`(other[, axis]) | Wrapper method for truediv
`Panel.floordiv`(other[, axis]) | Wrapper method for floordiv
`Panel.mod`(other[, axis]) | Wrapper method for mod
`Panel.pow`(other[, axis]) | Wrapper method for pow
`Panel.radd`(other[, axis]) | Wrapper method for radd
`Panel.rsub`(other[, axis]) | Wrapper method for rsub
`Panel.rmul`(other[, axis]) | Wrapper method for rmul
`Panel.rdiv`(other[, axis]) | Wrapper method for rtruediv
`Panel.rtruediv`(other[, axis]) | Wrapper method for rtruediv
`Panel.rfloordiv`(other[, axis]) | Wrapper method for rfloordiv
`Panel.rmod`(other[, axis]) | Wrapper method for rmod
`Panel.rpow`(other[, axis]) | Wrapper method for rpow
`Panel.lt`(other) | Wrapper for comparison method lt
`Panel.gt`(other) | Wrapper for comparison method gt
`Panel.le`(other) | Wrapper for comparison method le
`Panel.ge`(other) | Wrapper for comparison method ge
`Panel.ne`(other) | Wrapper for comparison method ne
`Panel.eq`(other) | Wrapper for comparison method eq

### Function application, GroupBy

`Panel.apply`(func[, axis]) | Applies function along input axis of the Panel
`Panel.groupby`(function[, axis]) | Group data on given axis, returning GroupBy object

### Computations / Descriptive Stats

`Panel.abs`() | Return an object with absolute value taken.
`Panel.clip`([lower, upper, out]) | Trim values at input threshold(s)
`Panel.clip_lower`(threshold) | Return copy of the input with values below given value truncated
`Panel.clip_upper`(threshold) | Return copy of input with values above given value truncated
`Panel.count`([axis]) | Return number of observations over requested axis.
`Panel.cummax`([axis, dtype, out, skipna]) | Return cumulative max over requested axis.
`Panel.cummin`([axis, dtype, out, skipna]) | Return cumulative min over requested axis.
`Panel.cumprod`([axis, dtype, out, skipna]) | Return cumulative prod over requested axis.
`Panel.cumsum`([axis, dtype, out, skipna]) | Return cumulative sum over requested axis.
`Panel.max`([axis, skipna, level, numeric_only]) | This method returns the maximum of the values in the object.
`Panel.mean`([axis, skipna, level, numeric_only]) | Return the mean of the values for the requested axis
`Panel.median`([axis, skipna, level, numeric_only]) | Return the median of the values for the requested axis
`Panel.min`([axis, skipna, level, numeric_only]) | This method returns the minimum of the values in the object.
`Panel.pct_change`([periods, fill_method, ...]) | Percent change over given number of periods
`Panel.prod`([axis, skipna, level, numeric_only]) | Return the product of the values for the requested axis
`Panel.skew`([axis, skipna, level, numeric_only]) | Return unbiased skew over requested axis
`Panel.sum`([axis, skipna, level, numeric_only]) | Return the sum of the values for the requested axis
`Panel.std`([axis, skipna, level, ddof]) | Return unbiased standard deviation over requested axis
`Panel.var`([axis, skipna, level, ddof]) | Return unbiased variance over requested axis

### Reindexing / Selection / Label manipulation

`Panel.add_prefix`(prefix) | Concatenate prefix string with panel items names.
`Panel.add_suffix`(suffix) | Concatenate suffix string with panel items names
`Panel.drop`(labels[, axis, level, inplace]) | Return new object with labels in requested axis removed
`Panel.filter`([items, like, regex, axis]) | Restrict the info axis to set of items or wildcard
`Panel.first`(offset) | Convenience method for subsetting initial periods of time series data
`Panel.last`(offset) | Convenience method for subsetting final periods of time series data
`Panel.reindex`([items, major_axis, minor_axis]) | Conform Panel to new index with optional filling logic, placing
`Panel.reindex_axis`(labels[, axis, method, ...]) | Conform input object to new index with optional filling logic,
`Panel.reindex_like`(other[, method, copy, limit]) | return an object with matching indicies to myself
`Panel.rename`([items, major_axis, minor_axis]) | Alter axes input function or functions.
`Panel.select`(crit[, axis]) | Return data corresponding to axis labels matching criteria
`Panel.take`(indices[, axis, convert, is_copy]) | Analogous to ndarray.take
`Panel.truncate`([before, after, axis, copy]) | Truncates a sorted NDFrame before and/or after some particular

### Missing data handling

`Panel.dropna`([axis, how, inplace]) | Drop 2D from panel, holding passed axis constant
`Panel.fillna`([value, method, axis, inplace, ...]) | Fill NA/NaN values using the specified method

### Reshaping, sorting, transposing

`Panel.sort_index`([axis, ascending]) | Sort object by labels (along an axis)
`Panel.swaplevel`(i, j[, axis]) | Swap levels i and j in a MultiIndex on a particular axis
`Panel.transpose`(*args, **kwargs) | Permute the dimensions of the Panel
`Panel.swapaxes`(axis1, axis2[, copy]) | Interchange axes and swap values axes appropriately
`Panel.conform`(frame[, axis]) | Conform input DataFrame to align with chosen axis pair.

### Combining / joining / merging

`Panel.join`(other[, how, lsuffix, rsuffix]) | Join items with other Panel either on major and minor axes column
`Panel.update`(other[, join, overwrite, ...]) | Modify Panel in place using non-NA values from passed

### Time series-related

`Panel.asfreq`(freq[, method, how, normalize]) | Convert all TimeSeries inside to specified frequency using DateOffset
`Panel.shift`(lags[, freq, axis]) | Shift major or minor axis by specified number of leads/lags.
`Panel.resample`(rule[, how, axis, ...]) | Convenience method for frequency conversion and resampling of regular time-series data.
`Panel.tz_convert`(tz[, axis, copy]) | Convert TimeSeries to target time zone. If it is time zone naive, it
`Panel.tz_localize`(tz[, axis, copy, infer_dst]) | Localize tz-naive TimeSeries to target time zone

### Serialization / IO / Conversion

`Panel.from_dict`(data[, intersect, orient, dtype]) | Construct Panel from dict of DataFrame objects
`Panel.to_pickle`(path) | Pickle (serialize) object to input file path
`Panel.to_excel`(path[, na_rep, engine]) | Write each DataFrame in Panel to a separate excel sheet
`Panel.to_hdf`(path_or_buf, key, **kwargs) | activate the HDFStore
`Panel.to_json`([path_or_buf, orient, ...]) | Convert the object to a JSON string.
`Panel.to_sparse`([fill_value, kind]) | Convert to SparsePanel
`Panel.to_frame`([filter_observations]) | Transform wide format into long (stacked) format as DataFrame whose
`Panel.to_clipboard`([excel, sep]) | Attempt to write text representation of object to the system clipboard

## Panel4D

### Constructor

`Panel4D`([data, labels, items, major_axis, ...]) | Represents a 4 dimensional structured

### Attributes and underlying data

Axes

> - labels: axis 1; each label corresponds to a Panel contained inside
> - items: axis 2; each item corresponds to a DataFrame contained inside
> - major_axis: axis 3; the index (rows) of each of the DataFrames
> - minor_axis: axis 4; the columns of each of the DataFrames

`Panel4D.values` | Numpy representation of NDFrame
`Panel4D.axes` | index(es) of the NDFrame
`Panel4D.ndim` | Number of axes / array dimensions
`Panel4D.shape` | tuple of axis dimensions
`Panel4D.dtypes` | Return the dtypes in this object
`Panel4D.ftypes` | Return the ftypes (indication of sparse/dense and dtype)
`Panel4D.get_dtype_counts`() | Return the counts of dtypes in this object
`Panel4D.get_ftype_counts`() | Return the counts of ftypes in this object

### Conversion

`Panel4D.astype`(dtype[, copy, raise_on_error]) | Cast object to input numpy.dtype
`Panel4D.copy`([deep]) | Make a copy of this object
`Panel4D.isnull`() | Return a boolean same-sized object indicating if the values are null
`Panel4D.notnull`() | Return a boolean same-sized object indicating if the values are

## Index

Many of these methods or variants thereof are available on the objects that contain an index (Series/Dataframe) and those should most likely be used before calling these methods directly.

`Index` | Immutable ndarray implementing an ordered, sliceable set.

### Modifying and Computations

`Index.copy`([names, name, dtype, deep]) | Make a copy of this object.
`Index.delete`(loc) | Make new Index with passed location deleted
`Index.diff`(other) | Compute sorted set difference of two Index objects
`Index.drop`(labels) | Make new Index with passed list of labels deleted
`Index.equals`(other) | Determines if two Index objects contain the same elements.
`Index.identical`(other) | Similar to equals, but check that other comparable attributes are
`Index.insert`(loc, item) | Make new Index inserting new item at location
`Index.order`([return_indexer, ascending]) | Return sorted copy of Index
`Index.reindex`(target[, method, level, ...]) | For Index, simply returns the new index and the results of
`Index.repeat`(repeats[, axis]) | Repeat elements of an array.
`Index.set_names`(names[, inplace]) | Set new names on index.
`Index.unique`() | Return array of unique values in the Index. Significantly faster than

### Conversion

`Index.astype`(dtype) |
`Index.tolist`() | Overridden version of ndarray.tolist
`Index.to_datetime`([dayfirst]) | For an Index containing strings or datetime.datetime objects, attempt
`Index.to_series`() | return a series with both index and values equal to the index keys

### Sorting

`Index.argsort`(*args, **kwargs) | See docstring for ndarray.argsort
`Index.order`([return_indexer, ascending]) | Return sorted copy of Index
`Index.sort`(*args, **kwargs) |

### Time-specific operations

`Index.shift`([periods, freq]) | Shift Index containing datetime objects by input number of periods and

### Combining / joining / merging

`Index.append`(other) | Append a collection of Index options together
`Index.intersection`(other) | Form the intersection of two Index objects. Sortedness of the result is
`Index.join`(other[, how, level, return_indexers]) | Internal API method. Compute join_index and indexers to conform data
`Index.union`(other) | Form the union of two Index objects and sorts if possible

### Selecting

`Index.get_indexer`(target[, method, limit]) | Compute indexer and mask for new index given the current index.
`Index.get_indexer_non_unique`(target, **kwargs) | return an indexer suitable for taking from a non unique index
`Index.get_level_values`(level) | Return vector of label values for requested level, equal to the length
`Index.get_loc`(key) | Get integer location for requested label
`Index.get_value`(series, key) | Fast lookup of value from 1-dimensional ndarray.
`Index.isin`(values) | Compute boolean array of whether each index value is found in the
`Index.slice_indexer`([start, end, step]) | For an ordered Index, compute the slice indexer for input labels and
`Index.slice_locs`([start, end]) | For an ordered Index, compute the slice locations for input labels

### Properties

`Index.is_monotonic` |
`Index.is_numeric`() |

## DatetimeIndex

`DatetimeIndex` | Immutable ndarray of datetime64 data, represented internally as int64, and

### Time/Date Components

`DatetimeIndex.year` |
`DatetimeIndex.month` | The month as January=1, December=12
`DatetimeIndex.day` |
`DatetimeIndex.hour` |
`DatetimeIndex.minute` |
`DatetimeIndex.second` |
`DatetimeIndex.microsecond` |
`DatetimeIndex.nanosecond` |
`DatetimeIndex.date` | Returns numpy array of datetime.date.
`DatetimeIndex.time` | Returns numpy array of datetime.time.
`DatetimeIndex.dayofyear` |
`DatetimeIndex.weekofyear` |
`DatetimeIndex.week` |
`DatetimeIndex.dayofweek` | The day of the week with Monday=0, Sunday=6
`DatetimeIndex.weekday` | The day of the week with Monday=0, Sunday=6
`DatetimeIndex.quarter` |

### Selecting

`DatetimeIndex.indexer_at_time`(time[, asof]) | Select values at particular time of day (e.g.
`DatetimeIndex.indexer_between_time`(...[, ...]) | Select values between particular times of day (e.g., 9:00-9:30AM)

### Time-specific operations

`DatetimeIndex.normalize`() | Return DatetimeIndex with times to midnight. Length is unaltered
`DatetimeIndex.snap`([freq]) | Snap time stamps to nearest occurring frequency
`DatetimeIndex.tz_convert`(tz) | Convert DatetimeIndex from one time zone to another (using pytz)
`DatetimeIndex.tz_localize`(tz[, infer_dst]) | Localize tz-naive DatetimeIndex to given time zone (using pytz)

### Conversion

`DatetimeIndex.to_datetime`([dayfirst]) |
`DatetimeIndex.to_period`([freq]) | Cast to PeriodIndex at a particular frequency
`DatetimeIndex.to_pydatetime`() | Return DatetimeIndex as object ndarray of datetime.datetime objects

## GroupBy

GroupBy objects are returned by groupby calls: `pandas.DataFrame.groupby()`, `pandas.Series.groupby()`, etc.

### Indexing, iteration

`GroupBy.__iter__`() | Groupby iterator
`GroupBy.groups` | dict {group name -> group labels}
`GroupBy.indices` | dict {group name -> group indices}
`GroupBy.get_group`(name[, obj]) | Constructs NDFrame from group with provided name

### Function application

`GroupBy.apply`(func, *args, **kwargs) | Apply function and combine results together in an intelligent way.
`GroupBy.aggregate`(func, *args, **kwargs) |
`GroupBy.transform`(func, *args, **kwargs) |

### Computations / Descriptive Stats

`GroupBy.mean`() | Compute mean of groups, excluding missing values
`GroupBy.median`() | Compute median of groups, excluding missing values
`GroupBy.std`([ddof]) | Compute standard deviation of groups, excluding missing values
`GroupBy.var`([ddof]) | Compute variance of groups, excluding missing values
`GroupBy.ohlc`() | Compute sum of values, excluding missing values

### Navigation

- index
- modules |
- next |
- previous |
- pandas 0.13.1 documentation »