# maxframe.dataframe.DataFrame

### *class* maxframe.dataframe.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False, chunk_size=None, gpu=None, sparse=None, num_partitions=None)

#### \_\_init_\_(data=None, index=None, columns=None, dtype=None, copy=False, chunk_size=None, gpu=None, sparse=None, num_partitions=None)

### Methods

| [`__init__`](#maxframe.dataframe.DataFrame.__init__)([data, index, columns, dtype, ...])                                                        |                                                                                                                                       |
|-------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------|
| [`abs`](maxframe.dataframe.DataFrame.abs.md#maxframe.dataframe.DataFrame.abs)()                                                                 |                                                                                                                                       |
| [`add`](maxframe.dataframe.DataFrame.add.md#maxframe.dataframe.DataFrame.add)(other[, axis, level, fill_value])                                 | Get Addition of dataframe and other, element-wise (binary operator add).                                                              |
| [`add_prefix`](maxframe.dataframe.DataFrame.add_prefix.md#maxframe.dataframe.DataFrame.add_prefix)(prefix)                                      | Prefix labels with string prefix.                                                                                                     |
| [`add_suffix`](maxframe.dataframe.DataFrame.add_suffix.md#maxframe.dataframe.DataFrame.add_suffix)(suffix)                                      | Suffix labels with string suffix.                                                                                                     |
| [`agg`](maxframe.dataframe.DataFrame.agg.md#maxframe.dataframe.DataFrame.agg)([func, axis])                                                     | Aggregate using one or more operations over the specified axis.                                                                       |
| [`aggregate`](maxframe.dataframe.DataFrame.aggregate.md#maxframe.dataframe.DataFrame.aggregate)([func, axis])                                   | Aggregate using one or more operations over the specified axis.                                                                       |
| [`align`](maxframe.dataframe.DataFrame.align.md#maxframe.dataframe.DataFrame.align)(other[, join, axis, level, copy, ...])                      | Align two objects on their axes with the specified join method.                                                                       |
| [`all`](maxframe.dataframe.DataFrame.all.md#maxframe.dataframe.DataFrame.all)([axis, bool_only, skipna, level, method])                         |                                                                                                                                       |
| [`any`](maxframe.dataframe.DataFrame.any.md#maxframe.dataframe.DataFrame.any)([axis, bool_only, skipna, level, method])                         |                                                                                                                                       |
| [`append`](maxframe.dataframe.DataFrame.append.md#maxframe.dataframe.DataFrame.append)(other[, ignore_index, ...])                              | Append rows of other to the end of caller, returning a new object.                                                                    |
| [`apply`](maxframe.dataframe.DataFrame.apply.md#maxframe.dataframe.DataFrame.apply)(func[, axis, raw, result_type, args, ...])                  | Apply a function along an axis of the DataFrame.                                                                                      |
| [`applymap`](maxframe.dataframe.DataFrame.applymap.md#maxframe.dataframe.DataFrame.applymap)(func[, na_action, dtypes, dtype, ...])             | Apply a function to a Dataframe elementwise.                                                                                          |
| `around`([decimals])                                                                                                                            | Round a DataFrame to a variable number of decimal places.                                                                             |
| [`assign`](maxframe.dataframe.DataFrame.assign.md#maxframe.dataframe.DataFrame.assign)(\*\*kwargs)                                              | Assign new columns to a DataFrame.                                                                                                    |
| [`astype`](maxframe.dataframe.DataFrame.astype.md#maxframe.dataframe.DataFrame.astype)(dtype[, copy, errors])                                   | Cast a pandas object to a specified dtype `dtype`.                                                                                    |
| [`at_time`](maxframe.dataframe.DataFrame.at_time.md#maxframe.dataframe.DataFrame.at_time)(time[, axis])                                         | Select values at particular time of day (e.g., 9:30AM).                                                                               |
| `backfill`([axis, inplace, limit, downcast])                                                                                                    | Synonym for [`DataFrame.fillna()`](maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna) with `method='bfill'`. |
| [`between_time`](maxframe.dataframe.DataFrame.between_time.md#maxframe.dataframe.DataFrame.between_time)(start_time, end_time[, ...])           | Select values between particular times of the day (e.g., 9:00-9:30 AM).                                                               |
| `bfill`([axis, inplace, limit, downcast])                                                                                                       | Synonym for [`DataFrame.fillna()`](maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna) with `method='bfill'`. |
| [`clip`](maxframe.dataframe.DataFrame.clip.md#maxframe.dataframe.DataFrame.clip)([lower, upper, axis, inplace])                                 | Trim values at input threshold(s).                                                                                                    |
| [`combine`](maxframe.dataframe.DataFrame.combine.md#maxframe.dataframe.DataFrame.combine)(other, func[, fill_value, overwrite])                 | Perform column-wise combine with another DataFrame.                                                                                   |
| [`combine_first`](maxframe.dataframe.DataFrame.combine_first.md#maxframe.dataframe.DataFrame.combine_first)(other)                              | Update null elements with value in the same location in other.                                                                        |
| [`compare`](maxframe.dataframe.DataFrame.compare.md#maxframe.dataframe.DataFrame.compare)(other[, align_axis, keep_shape, ...])                 | Compare to another DataFrame and show the differences.                                                                                |
| [`convert_dtypes`](maxframe.dataframe.DataFrame.convert_dtypes.md#maxframe.dataframe.DataFrame.convert_dtypes)([infer_objects, ...])            | Convert columns to best possible dtypes using dtypes supporting `pd.NA`.                                                              |
| [`copy`](maxframe.dataframe.DataFrame.copy.md#maxframe.dataframe.DataFrame.copy)()                                                              |                                                                                                                                       |
| `copy_from`(obj)                                                                                                                                |                                                                                                                                       |
| `copy_to`(target)                                                                                                                               |                                                                                                                                       |
| [`corr`](maxframe.dataframe.DataFrame.corr.md#maxframe.dataframe.DataFrame.corr)([method, min_periods])                                         | Compute pairwise correlation of columns, excluding NA/null values.                                                                    |
| [`corrwith`](maxframe.dataframe.DataFrame.corrwith.md#maxframe.dataframe.DataFrame.corrwith)(other[, axis, drop, method])                       | Compute pairwise correlation.                                                                                                         |
| [`count`](maxframe.dataframe.DataFrame.count.md#maxframe.dataframe.DataFrame.count)([axis, level, numeric_only])                                |                                                                                                                                       |
| [`cov`](maxframe.dataframe.DataFrame.cov.md#maxframe.dataframe.DataFrame.cov)([min_periods, ddof, numeric_only])                                | Compute pairwise covariance of columns, excluding NA/null values.                                                                     |
| `cummax`([axis, skipna])                                                                                                                        |                                                                                                                                       |
| `cummin`([axis, skipna])                                                                                                                        |                                                                                                                                       |
| `cumprod`([axis, skipna])                                                                                                                       |                                                                                                                                       |
| `cumsum`([axis, skipna])                                                                                                                        |                                                                                                                                       |
| [`describe`](maxframe.dataframe.DataFrame.describe.md#maxframe.dataframe.DataFrame.describe)([percentiles, include, exclude])                   | Generate descriptive statistics.                                                                                                      |
| [`diff`](maxframe.dataframe.DataFrame.diff.md#maxframe.dataframe.DataFrame.diff)([periods, axis])                                               | First discrete difference of element.                                                                                                 |
| [`div`](maxframe.dataframe.DataFrame.div.md#maxframe.dataframe.DataFrame.div)(other[, axis, level, fill_value])                                 | Get Floating division of dataframe and other, element-wise (binary operator truediv).                                                 |
| [`dot`](maxframe.dataframe.DataFrame.dot.md#maxframe.dataframe.DataFrame.dot)(other)                                                            | Compute the matrix multiplication between the DataFrame and other.                                                                    |
| [`drop`](maxframe.dataframe.DataFrame.drop.md#maxframe.dataframe.DataFrame.drop)([labels, axis, index, columns, level, ...])                    | Drop specified labels from rows or columns.                                                                                           |
| [`drop_duplicates`](maxframe.dataframe.DataFrame.drop_duplicates.md#maxframe.dataframe.DataFrame.drop_duplicates)([subset, keep, inplace, ...]) | Return DataFrame with duplicate rows removed.                                                                                         |
| [`droplevel`](maxframe.dataframe.DataFrame.droplevel.md#maxframe.dataframe.DataFrame.droplevel)(level[, axis])                                  | Return Series/DataFrame with requested index / column level(s) removed.                                                               |
| [`dropna`](maxframe.dataframe.DataFrame.dropna.md#maxframe.dataframe.DataFrame.dropna)([axis, how, thresh, subset, inplace, ...])               | Remove missing values.                                                                                                                |
| [`duplicated`](maxframe.dataframe.DataFrame.duplicated.md#maxframe.dataframe.DataFrame.duplicated)([subset, keep, method])                      | Return boolean Series denoting duplicate rows.                                                                                        |
| [`eq`](maxframe.dataframe.DataFrame.eq.md#maxframe.dataframe.DataFrame.eq)(other[, axis, level, fill_value])                                    | Get Equal to of dataframe and other, element-wise (binary operator eq).                                                               |
| [`eval`](maxframe.dataframe.DataFrame.eval.md#maxframe.dataframe.DataFrame.eval)(expr[, inplace])                                               | Evaluate a string describing operations on DataFrame columns.                                                                         |
| [`ewm`](maxframe.dataframe.DataFrame.ewm.md#maxframe.dataframe.DataFrame.ewm)([com, span, halflife, alpha, ...])                                | Provide exponential weighted functions.                                                                                               |
| `execute`([session])                                                                                                                            |                                                                                                                                       |
| [`expanding`](maxframe.dataframe.DataFrame.expanding.md#maxframe.dataframe.DataFrame.expanding)([min_periods, shift, reverse_range])            | Provide expanding transformations.                                                                                                    |
| `explode`(column[, ignore_index, ...])                                                                                                          | Transform each element of a list-like to a row, replicating index values.                                                             |
| `ffill`([axis, inplace, limit, downcast])                                                                                                       | Synonym for [`DataFrame.fillna()`](maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna) with `method='ffill'`. |
| [`fillna`](maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna)([value, method, axis, inplace, ...])                     | Fill NA/NaN values using the specified method.                                                                                        |
| [`filter`](maxframe.dataframe.DataFrame.filter.md#maxframe.dataframe.DataFrame.filter)([items, like, regex, axis])                              | Subset the dataframe rows or columns according to the specified index labels.                                                         |
| [`first_valid_index`](maxframe.dataframe.DataFrame.first_valid_index.md#maxframe.dataframe.DataFrame.first_valid_index)()                       | Return index for first non-NA value or None, if no non-NA value is found.                                                             |
| [`floordiv`](maxframe.dataframe.DataFrame.floordiv.md#maxframe.dataframe.DataFrame.floordiv)(other[, axis, level, fill_value])                  | Get Integer division of dataframe and other, element-wise (binary operator floordiv).                                                 |
| [`from_dict`](maxframe.dataframe.DataFrame.from_dict.md#maxframe.dataframe.DataFrame.from_dict)(data[, orient, dtype, columns])                 | Construct DataFrame from dict of array-like or dicts.                                                                                 |
| [`from_records`](maxframe.dataframe.DataFrame.from_records.md#maxframe.dataframe.DataFrame.from_records)(data[, index, exclude, ...])           | Convert structured or record ndarray to DataFrame.                                                                                    |
| `from_tensor`(tensor[, index, columns, gpu, ...])                                                                                               |                                                                                                                                       |
| [`ge`](maxframe.dataframe.DataFrame.ge.md#maxframe.dataframe.DataFrame.ge)(other[, axis, level, fill_value])                                    | Get Greater than or equal to of dataframe and other, element-wise (binary operator ge).                                               |
| [`groupby`](maxframe.dataframe.DataFrame.groupby.md#maxframe.dataframe.DataFrame.groupby)([by, level, as_index, sort, group_keys])              | Group DataFrame using a mapper or by a Series of columns.                                                                             |
| [`gt`](maxframe.dataframe.DataFrame.gt.md#maxframe.dataframe.DataFrame.gt)(other[, axis, level, fill_value])                                    | Get Greater than of dataframe and other, element-wise (binary operator gt).                                                           |
| [`head`](maxframe.dataframe.DataFrame.head.md#maxframe.dataframe.DataFrame.head)([n])                                                           | Return the first n rows.                                                                                                              |
| [`idxmax`](maxframe.dataframe.DataFrame.idxmax.md#maxframe.dataframe.DataFrame.idxmax)([axis, skipna])                                          | Return index of first occurrence of maximum over requested axis.                                                                      |
| [`idxmin`](maxframe.dataframe.DataFrame.idxmin.md#maxframe.dataframe.DataFrame.idxmin)([axis, skipna])                                          | Return index of first occurrence of minimum over requested axis.                                                                      |
| [`infer_objects`](maxframe.dataframe.DataFrame.infer_objects.md#maxframe.dataframe.DataFrame.infer_objects)([copy])                             | Attempt to infer better dtypes for object columns.                                                                                    |
| [`insert`](maxframe.dataframe.DataFrame.insert.md#maxframe.dataframe.DataFrame.insert)(loc, column, value[, allow_duplicates])                  | Insert column into DataFrame at specified location.                                                                                   |
| `isin`(values)                                                                                                                                  | Whether each element in the DataFrame is contained in values.                                                                         |
| [`isna`](maxframe.dataframe.DataFrame.isna.md#maxframe.dataframe.DataFrame.isna)()                                                              | Detect missing values.                                                                                                                |
| [`isnull`](maxframe.dataframe.DataFrame.isnull.md#maxframe.dataframe.DataFrame.isnull)()                                                        | Detect missing values.                                                                                                                |
| `iterrows`([batch_size, session])                                                                                                               | Iterate over DataFrame rows as (index, Series) pairs.                                                                                 |
| `itertuples`([index, name, batch_size, session])                                                                                                | Iterate over DataFrame rows as namedtuples.                                                                                           |
| [`join`](maxframe.dataframe.DataFrame.join.md#maxframe.dataframe.DataFrame.join)(other[, on, how, lsuffix, rsuffix, ...])                       | Join columns of another DataFrame.                                                                                                    |
| `keys`()                                                                                                                                        | Get the 'info axis' (see Indexing for more).                                                                                          |
| `kurt`([axis, skipna, level, numeric_only, ...])                                                                                                |                                                                                                                                       |
| `kurtosis`([axis, skipna, level, ...])                                                                                                          |                                                                                                                                       |
| [`last_valid_index`](maxframe.dataframe.DataFrame.last_valid_index.md#maxframe.dataframe.DataFrame.last_valid_index)()                          | Return index for last non-NA value or None, if no non-NA value is found.                                                              |
| [`le`](maxframe.dataframe.DataFrame.le.md#maxframe.dataframe.DataFrame.le)(other[, axis, level, fill_value])                                    | Get Less than or equal to of dataframe and other, element-wise (binary operator le).                                                  |
| [`lt`](maxframe.dataframe.DataFrame.lt.md#maxframe.dataframe.DataFrame.lt)(other[, axis, level, fill_value])                                    | Get Less than of dataframe and other, element-wise (binary operator lt).                                                              |
| [`map`](maxframe.dataframe.DataFrame.map.md#maxframe.dataframe.DataFrame.map)(func[, na_action, dtypes, dtype, skip_infer])                     | Apply a function to a Dataframe elementwise.                                                                                          |
| [`mask`](maxframe.dataframe.DataFrame.mask.md#maxframe.dataframe.DataFrame.mask)(cond[, other, inplace, axis, level, ...])                      | Replace values where the condition is True.                                                                                           |
| [`max`](maxframe.dataframe.DataFrame.max.md#maxframe.dataframe.DataFrame.max)([axis, skipna, level, numeric_only, method])                      |                                                                                                                                       |
| [`mean`](maxframe.dataframe.DataFrame.mean.md#maxframe.dataframe.DataFrame.mean)([axis, skipna, level, numeric_only, method])                   |                                                                                                                                       |
| [`median`](maxframe.dataframe.DataFrame.median.md#maxframe.dataframe.DataFrame.median)([axis, skipna, level, numeric_only, ...])                |                                                                                                                                       |
| [`melt`](maxframe.dataframe.DataFrame.melt.md#maxframe.dataframe.DataFrame.melt)([id_vars, value_vars, var_name, ...])                          | Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.                                                     |
| [`memory_usage`](maxframe.dataframe.DataFrame.memory_usage.md#maxframe.dataframe.DataFrame.memory_usage)([index, deep])                         | Return the memory usage of each column in bytes.                                                                                      |
| [`merge`](maxframe.dataframe.DataFrame.merge.md#maxframe.dataframe.DataFrame.merge)(right[, how, on, left_on, right_on, ...])                   | Merge DataFrame or named Series objects with a database-style join.                                                                   |
| [`min`](maxframe.dataframe.DataFrame.min.md#maxframe.dataframe.DataFrame.min)([axis, skipna, level, numeric_only, method])                      |                                                                                                                                       |
| [`mod`](maxframe.dataframe.DataFrame.mod.md#maxframe.dataframe.DataFrame.mod)(other[, axis, level, fill_value])                                 | Get Modulo of dataframe and other, element-wise (binary operator mod).                                                                |
| [`mode`](maxframe.dataframe.DataFrame.mode.md#maxframe.dataframe.DataFrame.mode)([axis, numeric_only, dropna, combine_size])                    | Get the mode(s) of each element along the selected axis.                                                                              |
| [`mul`](maxframe.dataframe.DataFrame.mul.md#maxframe.dataframe.DataFrame.mul)(other[, axis, level, fill_value])                                 | Get Multiplication of dataframe and other, element-wise (binary operator mul).                                                        |
| `multiply`(other[, axis, level, fill_value])                                                                                                    | Get Multiplication of dataframe and other, element-wise (binary operator mul).                                                        |
| [`ne`](maxframe.dataframe.DataFrame.ne.md#maxframe.dataframe.DataFrame.ne)(other[, axis, level, fill_value])                                    | Get Not equal to of dataframe and other, element-wise (binary operator ne).                                                           |
| [`nlargest`](maxframe.dataframe.DataFrame.nlargest.md#maxframe.dataframe.DataFrame.nlargest)(n, columns[, keep])                                | Return the first n rows ordered by columns in descending order.                                                                       |
| [`notna`](maxframe.dataframe.DataFrame.notna.md#maxframe.dataframe.DataFrame.notna)()                                                           | Detect existing (non-missing) values.                                                                                                 |
| [`notnull`](maxframe.dataframe.DataFrame.notnull.md#maxframe.dataframe.DataFrame.notnull)()                                                     | Detect existing (non-missing) values.                                                                                                 |
| [`nsmallest`](maxframe.dataframe.DataFrame.nsmallest.md#maxframe.dataframe.DataFrame.nsmallest)(n, columns[, keep])                             | Return the first n rows ordered by columns in ascending order.                                                                        |
| [`nunique`](maxframe.dataframe.DataFrame.nunique.md#maxframe.dataframe.DataFrame.nunique)([axis, dropna])                                       | Count distinct observations over requested axis.                                                                                      |
| `pad`([axis, inplace, limit, downcast])                                                                                                         | Synonym for [`DataFrame.fillna()`](maxframe.dataframe.DataFrame.fillna.md#maxframe.dataframe.DataFrame.fillna) with `method='ffill'`. |
| [`pct_change`](maxframe.dataframe.DataFrame.pct_change.md#maxframe.dataframe.DataFrame.pct_change)([periods, fill_method, limit, freq])         | Percentage change between the current and a prior element.                                                                            |
| [`pivot`](maxframe.dataframe.DataFrame.pivot.md#maxframe.dataframe.DataFrame.pivot)(columns[, index, values])                                   | Return reshaped DataFrame organized by given index / column values.                                                                   |
| [`pivot_table`](maxframe.dataframe.DataFrame.pivot_table.md#maxframe.dataframe.DataFrame.pivot_table)([values, index, columns, ...])            | Create a spreadsheet-style pivot table as a DataFrame.                                                                                |
| [`pop`](maxframe.dataframe.DataFrame.pop.md#maxframe.dataframe.DataFrame.pop)(item)                                                             | Return item and drop from frame.                                                                                                      |
| [`pow`](maxframe.dataframe.DataFrame.pow.md#maxframe.dataframe.DataFrame.pow)(other[, axis, level, fill_value])                                 | Get Exponential power of dataframe and other, element-wise (binary operator pow).                                                     |
| [`prod`](maxframe.dataframe.DataFrame.prod.md#maxframe.dataframe.DataFrame.prod)([axis, skipna, level, min_count, ...])                         |                                                                                                                                       |
| [`product`](maxframe.dataframe.DataFrame.product.md#maxframe.dataframe.DataFrame.product)([axis, skipna, level, min_count, ...])                |                                                                                                                                       |
| [`quantile`](maxframe.dataframe.DataFrame.quantile.md#maxframe.dataframe.DataFrame.quantile)([q, axis, numeric_only, interpolation])            | Return values at the given quantile over requested axis.                                                                              |
| [`query`](maxframe.dataframe.DataFrame.query.md#maxframe.dataframe.DataFrame.query)(expr[, inplace])                                            | Query the columns of a DataFrame with a boolean expression.                                                                           |
| [`radd`](maxframe.dataframe.DataFrame.radd.md#maxframe.dataframe.DataFrame.radd)(other[, axis, level, fill_value])                              | Get Addition of dataframe and other, element-wise (binary operator radd).                                                             |
| [`rank`](maxframe.dataframe.DataFrame.rank.md#maxframe.dataframe.DataFrame.rank)([axis, method, numeric_only, ...])                             | Compute numerical data ranks (1 through n) along axis.                                                                                |
| [`rdiv`](maxframe.dataframe.DataFrame.rdiv.md#maxframe.dataframe.DataFrame.rdiv)(other[, axis, level, fill_value])                              | Get Floating division of dataframe and other, element-wise (binary operator rtruediv).                                                |
| `rechunk`(chunk_size[, reassign_worker])                                                                                                        |                                                                                                                                       |
| [`reindex`](maxframe.dataframe.DataFrame.reindex.md#maxframe.dataframe.DataFrame.reindex)([labels, index, columns, axis, ...])                  | Conform Series/DataFrame to new index with optional filling logic.                                                                    |
| [`reindex_like`](maxframe.dataframe.DataFrame.reindex_like.md#maxframe.dataframe.DataFrame.reindex_like)(other[, method, copy, limit, ...])     | Return an object with matching indices as other object.                                                                               |
| [`rename`](maxframe.dataframe.DataFrame.rename.md#maxframe.dataframe.DataFrame.rename)([mapper, index, columns, axis, copy, ...])               | Alter axes labels.                                                                                                                    |
| [`rename_axis`](maxframe.dataframe.DataFrame.rename_axis.md#maxframe.dataframe.DataFrame.rename_axis)([mapper, index, columns, axis, ...])      | Set the name of the axis for the index or columns.                                                                                    |
| [`reorder_levels`](maxframe.dataframe.DataFrame.reorder_levels.md#maxframe.dataframe.DataFrame.reorder_levels)(order[, axis])                   | Rearrange index levels using input order.                                                                                             |
| `replace`([to_replace, value, inplace, limit, ...])                                                                                             | Replace values given in to_replace with value.                                                                                        |
| [`reset_index`](maxframe.dataframe.DataFrame.reset_index.md#maxframe.dataframe.DataFrame.reset_index)([level, drop, inplace, ...])              | Reset the index, or a level of it.                                                                                                    |
| [`rfloordiv`](maxframe.dataframe.DataFrame.rfloordiv.md#maxframe.dataframe.DataFrame.rfloordiv)(other[, axis, level, fill_value])               | Get Integer division of dataframe and other, element-wise (binary operator rfloordiv).                                                |
| [`rmod`](maxframe.dataframe.DataFrame.rmod.md#maxframe.dataframe.DataFrame.rmod)(other[, axis, level, fill_value])                              | Get Modulo of dataframe and other, element-wise (binary operator rmod).                                                               |
| [`rmul`](maxframe.dataframe.DataFrame.rmul.md#maxframe.dataframe.DataFrame.rmul)(other[, axis, level, fill_value])                              | Get Multiplication of dataframe and other, element-wise (binary operator rmul).                                                       |
| [`rolling`](maxframe.dataframe.DataFrame.rolling.md#maxframe.dataframe.DataFrame.rolling)(window[, min_periods, center, ...])                   | Provide rolling window calculations.                                                                                                  |
| [`round`](maxframe.dataframe.DataFrame.round.md#maxframe.dataframe.DataFrame.round)([decimals])                                                 | Round a DataFrame to a variable number of decimal places.                                                                             |
| [`rpow`](maxframe.dataframe.DataFrame.rpow.md#maxframe.dataframe.DataFrame.rpow)(other[, axis, level, fill_value])                              | Get Exponential power of dataframe and other, element-wise (binary operator rpow).                                                    |
| [`rsub`](maxframe.dataframe.DataFrame.rsub.md#maxframe.dataframe.DataFrame.rsub)(other[, axis, level, fill_value])                              | Get Subtraction of dataframe and other, element-wise (binary operator rsubtract).                                                     |
| [`rtruediv`](maxframe.dataframe.DataFrame.rtruediv.md#maxframe.dataframe.DataFrame.rtruediv)(other[, axis, level, fill_value])                  | Get Floating division of dataframe and other, element-wise (binary operator rtruediv).                                                |
| [`sample`](maxframe.dataframe.DataFrame.sample.md#maxframe.dataframe.DataFrame.sample)([n, frac, replace, weights, ...])                        | Return a random sample of items from an axis of object.                                                                               |
| [`select_dtypes`](maxframe.dataframe.DataFrame.select_dtypes.md#maxframe.dataframe.DataFrame.select_dtypes)([include, exclude])                 | Return a subset of the DataFrame's columns based on the column dtypes.                                                                |
| [`sem`](maxframe.dataframe.DataFrame.sem.md#maxframe.dataframe.DataFrame.sem)([axis, skipna, level, ddof, ...])                                 |                                                                                                                                       |
| [`set_axis`](maxframe.dataframe.DataFrame.set_axis.md#maxframe.dataframe.DataFrame.set_axis)(labels[, axis, inplace])                           | Assign desired index to given axis.                                                                                                   |
| [`set_index`](maxframe.dataframe.DataFrame.set_index.md#maxframe.dataframe.DataFrame.set_index)(keys[, drop, append, inplace, ...])             | Set the DataFrame index using existing columns.                                                                                       |
| [`shift`](maxframe.dataframe.DataFrame.shift.md#maxframe.dataframe.DataFrame.shift)([periods, freq, axis, fill_value])                          | Shift index by desired number of periods with an optional time freq.                                                                  |
| `skew`([axis, skipna, level, numeric_only, ...])                                                                                                |                                                                                                                                       |
| [`sort_index`](maxframe.dataframe.DataFrame.sort_index.md#maxframe.dataframe.DataFrame.sort_index)([axis, level, ascending, ...])               | Sort object by labels (along an axis).                                                                                                |
| [`sort_values`](maxframe.dataframe.DataFrame.sort_values.md#maxframe.dataframe.DataFrame.sort_values)(by[, axis, ascending, inplace, ...])      | Sort by the values along either axis.                                                                                                 |
| [`stack`](maxframe.dataframe.DataFrame.stack.md#maxframe.dataframe.DataFrame.stack)([level, dropna])                                            | Stack the prescribed level(s) from columns to index.                                                                                  |
| [`std`](maxframe.dataframe.DataFrame.std.md#maxframe.dataframe.DataFrame.std)([axis, skipna, level, ddof, ...])                                 |                                                                                                                                       |
| [`sub`](maxframe.dataframe.DataFrame.sub.md#maxframe.dataframe.DataFrame.sub)(other[, axis, level, fill_value])                                 | Get Subtraction of dataframe and other, element-wise (binary operator subtract).                                                      |
| [`sum`](maxframe.dataframe.DataFrame.sum.md#maxframe.dataframe.DataFrame.sum)([axis, skipna, level, min_count, ...])                            |                                                                                                                                       |
| [`swaplevel`](maxframe.dataframe.DataFrame.swaplevel.md#maxframe.dataframe.DataFrame.swaplevel)([i, j, axis])                                   | Swap levels i and j in a `MultiIndex`.                                                                                                |
| [`tail`](maxframe.dataframe.DataFrame.tail.md#maxframe.dataframe.DataFrame.tail)([n])                                                           | Return the last n rows.                                                                                                               |
| [`take`](maxframe.dataframe.DataFrame.take.md#maxframe.dataframe.DataFrame.take)(indices[, axis])                                               | Return the elements in the given *positional* indices along an axis.                                                                  |
| [`to_clipboard`](maxframe.dataframe.DataFrame.to_clipboard.md#maxframe.dataframe.DataFrame.to_clipboard)(\*[, excel, sep, batch_size, ...])     | Copy object to the system clipboard.                                                                                                  |
| [`to_csv`](maxframe.dataframe.DataFrame.to_csv.md#maxframe.dataframe.DataFrame.to_csv)(path[, sep, na_rep, float_format, ...])                  | Write object to a comma-separated values (csv) file.                                                                                  |
| [`to_dict`](maxframe.dataframe.DataFrame.to_dict.md#maxframe.dataframe.DataFrame.to_dict)([orient, into, index, batch_size, ...])               | Convert the DataFrame to a dictionary.                                                                                                |
| [`to_json`](maxframe.dataframe.DataFrame.to_json.md#maxframe.dataframe.DataFrame.to_json)([path, orient, date_format, ...])                     | Convert the object to a JSON string.                                                                                                  |
| [`to_odps_table`](maxframe.dataframe.DataFrame.to_odps_table.md#maxframe.dataframe.DataFrame.to_odps_table)(table[, partition, ...])            | Write DataFrame object into a MaxCompute (ODPS) table.                                                                                |
| [`to_pandas`](maxframe.dataframe.DataFrame.to_pandas.md#maxframe.dataframe.DataFrame.to_pandas)([session])                                      |                                                                                                                                       |
| [`to_parquet`](maxframe.dataframe.DataFrame.to_parquet.md#maxframe.dataframe.DataFrame.to_parquet)(path[, engine, compression, ...])            | Write a DataFrame to the binary parquet format, each chunk will be written to a Parquet file.                                         |
| `to_tensor`()                                                                                                                                   |                                                                                                                                       |
| [`transform`](maxframe.dataframe.DataFrame.transform.md#maxframe.dataframe.DataFrame.transform)(func[, axis, dtypes, skip_infer])               | Call `func` on self producing a DataFrame with transformed values.                                                                    |
| `transpose`()                                                                                                                                   | Transpose index and columns.                                                                                                          |
| [`truediv`](maxframe.dataframe.DataFrame.truediv.md#maxframe.dataframe.DataFrame.truediv)(other[, axis, level, fill_value])                     | Get Floating division of dataframe and other, element-wise (binary operator truediv).                                                 |
| [`truncate`](maxframe.dataframe.DataFrame.truncate.md#maxframe.dataframe.DataFrame.truncate)([before, after, axis, copy])                       | Truncate a Series or DataFrame before and after some index value.                                                                     |
| [`tshift`](maxframe.dataframe.DataFrame.tshift.md#maxframe.dataframe.DataFrame.tshift)([periods, freq, axis])                                   | Shift the time index, using the index's frequency if available.                                                                       |
| [`unstack`](maxframe.dataframe.DataFrame.unstack.md#maxframe.dataframe.DataFrame.unstack)([level, fill_value])                                  | Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.                                                            |
| [`update`](maxframe.dataframe.DataFrame.update.md#maxframe.dataframe.DataFrame.update)(other[, join, overwrite, ...])                           | Modify in place using non-NA values from another DataFrame.                                                                           |
| [`value_counts`](maxframe.dataframe.DataFrame.value_counts.md#maxframe.dataframe.DataFrame.value_counts)([subset, normalize, sort, ...])        |                                                                                                                                       |
| [`var`](maxframe.dataframe.DataFrame.var.md#maxframe.dataframe.DataFrame.var)([axis, skipna, level, ddof, ...])                                 |                                                                                                                                       |
| [`where`](maxframe.dataframe.DataFrame.where.md#maxframe.dataframe.DataFrame.where)(cond[, other, inplace, axis, level, ...])                   | Replace values where the condition is False.                                                                                          |
| [`xs`](maxframe.dataframe.DataFrame.xs.md#maxframe.dataframe.DataFrame.xs)(key[, axis, level, drop_level])                                      | Return cross-section from the Series/DataFrame.                                                                                       |

### Attributes

| `T`                                                                                       |                                                                    |
|-------------------------------------------------------------------------------------------|--------------------------------------------------------------------|
| [`at`](maxframe.dataframe.DataFrame.at.md#maxframe.dataframe.DataFrame.at)                | Access a single value for a row/column label pair.                 |
| [`columns`](maxframe.dataframe.DataFrame.columns.md#maxframe.dataframe.DataFrame.columns) |                                                                    |
| `data`                                                                                    |                                                                    |
| [`dtypes`](maxframe.dataframe.DataFrame.dtypes.md#maxframe.dataframe.DataFrame.dtypes)    | Return the dtypes in the DataFrame.                                |
| [`iat`](maxframe.dataframe.DataFrame.iat.md#maxframe.dataframe.DataFrame.iat)             | Access a single value for a row/column pair by integer position.   |
| [`iloc`](maxframe.dataframe.DataFrame.iloc.md#maxframe.dataframe.DataFrame.iloc)          | Purely integer-location based indexing for selection by position.  |
| [`index`](maxframe.dataframe.DataFrame.index.md#maxframe.dataframe.DataFrame.index)       |                                                                    |
| [`loc`](maxframe.dataframe.DataFrame.loc.md#maxframe.dataframe.DataFrame.loc)             | Access a group of rows and columns by label(s) or a boolean array. |
| [`ndim`](maxframe.dataframe.DataFrame.ndim.md#maxframe.dataframe.DataFrame.ndim)          | Return an int representing the number of axes / array dimensions.  |
| [`shape`](maxframe.dataframe.DataFrame.shape.md#maxframe.dataframe.DataFrame.shape)       |                                                                    |
| `size`                                                                                    |                                                                    |
| `type_name`                                                                               |                                                                    |
| `values`                                                                                  |                                                                    |
