- 2.17.0 (latest)
- 2.16.0
- 2.15.0
- 2.14.0
- 2.13.0
- 2.12.0
- 2.11.0
- 2.10.0
- 2.9.0
- 2.8.0
- 2.7.0
- 2.6.0
- 2.5.0
- 2.4.0
- 2.3.0
- 2.2.0
- 2.0.0-dev0
- 1.36.0
- 1.35.0
- 1.34.0
- 1.33.0
- 1.32.0
- 1.31.0
- 1.30.0
- 1.29.0
- 1.28.0
- 1.27.0
- 1.26.0
- 1.25.0
- 1.24.0
- 1.22.0
- 1.21.0
- 1.20.0
- 1.19.0
- 1.18.0
- 1.17.0
- 1.16.0
- 1.15.0
- 1.14.0
- 1.13.0
- 1.12.0
- 1.11.1
- 1.10.0
- 1.9.0
- 1.8.0
- 1.7.0
- 1.6.0
- 1.5.0
- 1.4.0
- 1.3.0
- 1.2.0
- 1.1.0
- 1.0.0
- 0.26.0
- 0.25.0
- 0.24.0
- 0.23.0
- 0.22.0
- 0.21.0
- 0.20.1
- 0.19.2
- 0.18.0
- 0.17.0
- 0.16.0
- 0.15.0
- 0.14.1
- 0.13.0
- 0.12.0
- 0.11.0
- 0.10.0
- 0.9.0
- 0.8.0
- 0.7.0
- 0.6.0
- 0.5.0
- 0.4.0
- 0.3.0
- 0.2.0
DataFrame
(
data
=
None
,
index
:
vendored_pandas_typing
.
Axes
|
None
=
None
,
columns
:
vendored_pandas_typing
.
Axes
|
None
=
None
,
dtype
:
typing
.
Optional
[
bigframes
.
dtypes
.
DtypeString
|
bigframes
.
dtypes
.
Dtype
]
=
None
,
copy
:
typing
.
Optional
[
bool
]
=
None
,
*
,
session
:
typing
.
Optional
[
bigframes
.
session
.
Session
]
=
None
)
Two-dimensional, size-mutable, potentially heterogeneous tabular data.
Data structure also contains labeled axes (rows and columns). Arithmetic operations align on both row and column labels. Can be thought of as a dict-like container for Series objects. The primary pandas data structure.
Properties
axes
Return a list representing the axes of the DataFrame.
It has the row axis labels and column axis labels as the only members. They are returned in that order.
Examples
df = pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]})
df.axes
[RangeIndex(start=0, stop=2, step=1), Index(['col1', 'col2'],
dtype='object')]
columns
The column labels of the DataFrame.
dtypes
Return the dtypes in the DataFrame.
This returns a Series with the data type of each column. The result's index is the original DataFrame's columns. Columns with mixed types aren't supported yet in BigQuery DataFrames.
empty
Indicates whether Series/DataFrame is empty.
True if Series/DataFrame is entirely empty (no items), meaning any of the axes are of length 0.
bool
iloc
Purely integer-location based indexing for selection by position.
.iloc[]
is primarily integer position based (from 0
to length-1
of the axis), but may also be used with a boolean
array.
Allowed inputs are:
- Not supported yetAn integer, e.g.
5. - Not supported yetA list or array of integers, e.g.
[4, 3, 0]. - A slice object with ints, e.g.
1:7. - Not supported yetA boolean array.
- Not supported yetA
callablefunction with one argument (the calling Series or DataFrame) that returns valid output for indexing (one of the above). This is useful in method chains, when you don't have a reference to the calling object, but would like to base your selection on some value. - Not supported yetA tuple of row and column indexes. The tuple
elements consist of one of the above inputs, e.g.
(0, 1).
.iloc
will raise IndexError
if a requested indexer is
out-of-bounds, except slice
indexers which allow out-of-bounds
indexing (this conforms with python/numpy slice
semantics).
index
The index (row labels) of the DataFrame.
The index of a DataFrame is a series of labels that identify each row. The labels can be integers, strings, or any other hashable type. The index is used for label-based access and alignment, and can be accessed or modified using this attribute.
loc
Access a group of rows and columns by label(s) or a boolean array.
.loc[]
is primarily label based, but may also be used with a
boolean array.
Allowed inputs are:
- A single label, e.g.
5or'a', (note that5is interpreted as a label of the index, and neveras an integer position along the index). - A list of labels, e.g.
['a', 'b', 'c']. - A boolean series of the same length as the axis being sliced,
e.g.
[True, False, True]. - An alignable Index. The index of the returned selection will be the input.
- Not supported yetAn alignable boolean Series. The index of the key will be aligned before masking.
- Not supported yetA slice object with labels, e.g.
'a':'f'. Note: contrary to usual python slices, boththe start and the stop are included. - Not supported yetA
callablefunction with one argument (the calling Series or DataFrame) that returns valid output for indexing (one of the above).
NotImplementError
ndim
Return an int representing the number of axes / array dimensions.
int
query_job
BigQuery job metadata for the most recent query.
shape
Return a tuple representing the dimensionality of the DataFrame.
size
Return an int representing the number of elements in this object.
int
sql
Compiles this DataFrame's expression tree to SQL.
values
Return the values of DataFrame in the form of a NumPy array.
Methods
__array_ufunc__
__array_ufunc__
(
ufunc
:
numpy
.
ufunc
,
method
:
str
,
*
inputs
,
**
kwargs
)
-
> bigframes
.
dataframe
.
DataFrame
Used to support numpy ufuncs. See: https://numpy.org/doc/stable/reference/ufuncs.html
__getitem__
__getitem__
(
key
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
],
pandas
.
core
.
indexes
.
base
.
Index
,
bigframes
.
series
.
Series
,
]
)
Gets the specified column(s) from the DataFrame.
__repr__
__repr__
()
-
> str
Converts a DataFrame to a string. Calls to_pandas.
Only represents the first <xref uid="bigframes.options">bigframes.options</xref>.display.max_rows
.
__setitem__
__setitem__
(
key
:
str
,
value
:
typing
.
Union
[
bigframes
.
series
.
Series
,
int
,
float
,
typing
.
Callable
]
)
Modify or insert a column into the DataFrame.
Note: This does notmodify the original table the DataFrame was derived from.
abs
abs
()
-
> bigframes
.
dataframe
.
DataFrame
Return a Series/DataFrame with absolute numeric value of each element.
This function only applies to elements that are all numeric.
add
add
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get addition of DataFrame and other, element-wise (binary operator +
).
Equivalent to dataframe + other
. With reverse version, radd
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
add_prefix
add_prefix
(
prefix
:
str
,
axis
:
int
|
str
|
None
=
None
)
-
> DataFrame
Prefix labels with string prefix
.
For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed.
prefix
str
The string to add before each label.
axis
int or str or None, default None
{{0 or 'index', 1 or 'columns', None}}
, default None. Axis to add prefix on.
add_suffix
add_suffix
(
suffix
:
str
,
axis
:
int
|
str
|
None
=
None
)
-
> DataFrame
Suffix labels with string suffix
.
For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed.
agg
agg
(
func
:
str
|
typing
.
Sequence
[
str
])
-
> DataFrame
|
bigframes
.
series
.
Series
Aggregate using one or more operations over the specified axis.
func
function
Function to use for aggregating the data. Accepted combinations are: string function name, list of function names, e.g. ['sum', 'mean']
.
aggregate
aggregate
(
func
:
str
|
typing
.
Sequence
[
str
])
-
> DataFrame
|
bigframes
.
series
.
Series
Aggregate using one or more operations over the specified axis.
func
function
Function to use for aggregating the data. Accepted combinations are: string function name, list of function names, e.g. ['sum', 'mean']
.
align
align
(
other
:
typing
.
Union
[
bigframes
.
dataframe
.
DataFrame
,
bigframes
.
series
.
Series
],
join
:
str
=
"outer"
,
axis
:
typing
.
Optional
[
typing
.
Union
[
str
,
int
]]
=
None
,
)
-
> typing
.
Tuple
[
typing
.
Union
[
bigframes
.
dataframe
.
DataFrame
,
bigframes
.
series
.
Series
],
typing
.
Union
[
bigframes
.
dataframe
.
DataFrame
,
bigframes
.
series
.
Series
],
]
Align two objects on their axes with the specified join method.
Join method is specified for each axis Index.
join
{{'outer', 'inner', 'left', 'right'}}, default 'outer'
Type of alignment to be performed. left: use only keys from left frame, preserve key order. right: use only keys from right frame, preserve key order. outer: use union of keys from both frames, sort keys lexicographically. inner: use intersection of keys from both frames, preserve the order of the left keys.
axis
allowed axis of the other object, default None
Align on index (0), columns (1), or both (None).
tuple of (DataFrame, type of other)
all
all
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
bool_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return whether all elements are True, potentially over an axis.
Returns True unless there at least one element within a Series or along a DataFrame axis that is False or equivalent (e.g. zero or empty).
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
bool_only
bool. default False
Include only boolean columns.
any
any
(
*
,
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
bool_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return whether any element is True, potentially over an axis.
Returns False unless there is at least one element within a series or along a Dataframe axis that is True or equivalent (e.g. non-zero or non-empty).
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
bool_only
bool. default False
Include only boolean columns.
apply
apply
(
func
,
*
,
args
:
typing
.
Tuple
=
(),
**
kwargs
)
Apply a function along an axis of the DataFrame.
Objects passed to the function are Series objects whose index is
the DataFrame's index ( axis=0
) the final return type
is inferred from the return type of the applied function.
func
function
Function to apply to each column or row.
args
tuple
Positional arguments to pass to func
in addition to the array/series.
pandas.Series or bigframes.DataFrame
func
along the given axis of the DataFrame.applymap
applymap
(
func
,
na_action
:
typing
.
Optional
[
str
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Apply a function to a Dataframe elementwise.
This method applies a function that accepts and returns a scalar to every element of a DataFrame.
na_action
Optional[str], default None
{None, 'ignore'}
, default None. If ‘ignore’, propagate NaN values, without passing them to func.
bigframes.dataframe.DataFrame
assign
assign
(
**
kwargs
)
-
> bigframes
.
dataframe
.
DataFrame
Assign new columns to a DataFrame.
Returns a new object with all original columns in addition to new ones. Existing columns that are re-assigned will be overwritten.
bigframes.dataframe.DataFrame
astype
astype
(
dtype
:
typing
.
Union
[
typing
.
Literal
[
"boolean"
,
"Float64"
,
"Int64"
,
"string"
,
"string[pyarrow]"
,
"timestamp[us, tz=UTC][pyarrow]"
,
"timestamp[us][pyarrow]"
,
"date32[day][pyarrow]"
,
"time64[us][pyarrow]"
,
],
pandas
.
core
.
arrays
.
boolean
.
BooleanDtype
,
pandas
.
core
.
arrays
.
floating
.
Float64Dtype
,
pandas
.
core
.
arrays
.
integer
.
Int64Dtype
,
pandas
.
core
.
arrays
.
string_
.
StringDtype
,
pandas
.
core
.
dtypes
.
dtypes
.
ArrowDtype
,
]
)
-
> bigframes
.
dataframe
.
DataFrame
Cast a pandas object to a specified dtype dtype
.
dtype
str or pandas.ExtensionDtype
A dtype supported by BigQuery DataFrame include 'boolean','Float64','Int64', 'string', 'tring[pyarrow]','timestamp[us, tz=UTC][pyarrow]', 'timestamp us][pyarrow]
','date32 day][pyarrow]
','time64 us][pyarrow]
' A pandas.ExtensionDtype include pandas.BooleanDtype(), pandas.Float64Dtype(), pandas.Int64Dtype(), pandas.StringDtype(storage="pyarrow"), pd.ArrowDtype(pa.date32()), pd.ArrowDtype(pa.time64("us")), pd.ArrowDtype(pa.timestamp("us")), pd.ArrowDtype(pa.timestamp("us", tz="UTC")).
bfill
bfill
(
*
,
limit
:
typing
.
Optional
[
int
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Fill NA/NaN values by using the next valid observation to fill the gap.
Series/DataFrame or None
combine
combine
(
other
:
bigframes
.
dataframe
.
DataFrame
,
func
:
typing
.
Callable
[
[
bigframes
.
series
.
Series
,
bigframes
.
series
.
Series
],
bigframes
.
series
.
Series
],
fill_value
=
None
,
overwrite
:
bool
=
True
,
*
,
how
:
str
=
"outer"
)
-
> bigframes
.
dataframe
.
DataFrame
Perform column-wise combine with another DataFrame.
Combines a DataFrame with other
DataFrame using func
to element-wise combine columns. The row and column indexes of the
resulting DataFrame will be the union of the two.
other
DataFrame
The DataFrame to merge column-wise.
func
function
Function that takes two series as inputs and return a Series or a scalar. Used to merge the two dataframes column by columns.
fill_value
scalar value, default None
The value to fill NaNs with prior to passing any column to the merge func.
overwrite
bool, default True
If True, columns in self
that do not exist in other
will be overwritten with NaNs.
DataFrame
combine_first
combine_first
(
other
:
bigframes
.
dataframe
.
DataFrame
)
Update null elements with value in the same location in other
.
Combine two DataFrame objects by filling null values in one DataFrame with non-null values from other DataFrame. The row and column indexes of the resulting DataFrame will be the union of the two. The resulting dataframe contains the 'first' dataframe values and overrides the second one values where both first.loc[index, col] and second.loc[index, col] are not missing values, upon calling first.combine_first(second).
other
DataFrame
Provided DataFrame to use to fill null values.
DataFrame
copy
copy
()
-
> bigframes
.
dataframe
.
DataFrame
Make a copy of this object's indices and data.
A new object will be created with a copy of the calling object's data and indices. Modifications to the data or indices of the copy will not be reflected in the original object.
count
count
(
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Count non-NA cells for each column or row.
The values None
, NaN
, NaT
, and optionally numpy.inf
(depending
on pandas.options.mode.use_inf_as_na
) are considered NA.
numeric_only
bool, default False
Include only float
, int
or boolean
data.
level
is specified returns a DataFrame
.cummax
cummax
()
-
> bigframes
.
dataframe
.
DataFrame
Return cumulative maximum over a DataFrame axis.
Returns a DataFrame of the same size containing the cumulative maximum.
bigframes.dataframe.DataFrame
cummin
cummin
()
-
> bigframes
.
dataframe
.
DataFrame
Return cumulative minimum over a DataFrame axis.
Returns a DataFrame of the same size containing the cumulative minimum.
bigframes.dataframe.DataFrame
cumprod
cumprod
()
-
> bigframes
.
dataframe
.
DataFrame
Return cumulative product over a DataFrame axis.
Returns a DataFrame of the same size containing the cumulative product.
bigframes.dataframe.DataFrame
cumsum
cumsum
()
Return cumulative sum over a DataFrame axis.
Returns a DataFrame of the same size containing the cumulative sum.
bigframes.dataframe.DataFrame
describe
describe
()
-
> bigframes
.
dataframe
.
DataFrame
Generate descriptive statistics.
Descriptive statistics include those that summarize the central
tendency, dispersion and shape of a
dataset's distribution, excluding NaN
values.
Only supports numeric columns.
bigframes.dataframe.DataFrame
diff
diff
(
periods
:
int
=
1
)
-
> bigframes
.
dataframe
.
DataFrame
First discrete difference of element.
Calculates the difference of a DataFrame element compared with another element in the DataFrame (default is element in previous row).
periods
int, default 1
Periods to shift for calculating difference, accepts negative values.
bigframes.dataframe.DataFrame
div
div
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get floating division of DataFrame and other, element-wise (binary operator /
).
Equivalent to dataframe / other
. With reverse version, rtruediv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
divide
divide
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get floating division of DataFrame and other, element-wise (binary operator /
).
Equivalent to dataframe / other
. With reverse version, rtruediv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
drop
drop
(
labels
:
typing
.
Optional
[
typing
.
Any
]
=
None
,
*
,
axis
:
typing
.
Union
[
int
,
str
]
=
0
,
index
:
typing
.
Optional
[
typing
.
Any
]
=
None
,
columns
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
level
:
typing
.
Optional
[
typing
.
Union
[
str
,
int
]]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Drop specified labels from columns.
Remove columns by directly specifying column names.
KeyError
bigframes.dataframe.DataFrame
drop_duplicates
drop_duplicates
(
subset
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
*
,
keep
:
str
=
"first"
)
-
> bigframes
.
dataframe
.
DataFrame
Return DataFrame with duplicate rows removed.
Considering certain columns is optional. Indexes, including time indexes are ignored.
subset
column label or sequence of labels, optional
Only consider certain columns for identifying duplicates, by default use all of the columns.
keep
{'first', 'last', False
}, default 'first'
Determines which duplicates (if any) to keep. - 'first' : Drop duplicates except for the first occurrence. - 'last' : Drop duplicates except for the last occurrence. - False
: Drop all duplicates.
bigframes.dataframe.DataFrame
droplevel
droplevel
(
level
:
LevelsType
,
axis
:
int
|
str
=
0
)
Return DataFrame with requested index / column level(s) removed.
level
int, str, or list-like
If a string is given, must be the name of a level If list-like, elements must be names or positional indexes of levels.
axis
{0 or 'index', 1 or 'columns'}, default 0
Axis along which the level(s) is removed: * 0 or 'index': remove level(s) in column. * 1 or 'columns': remove level(s) in row.
DataFrame
dropna
dropna
(
*
,
axis
:
int
|
str
=
0
,
inplace
:
bool
=
False
,
how
:
str
=
"any"
,
ignore_index
=
False
)
-
> DataFrame
Remove missing values.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Determine if rows or columns which contain missing values are removed. * 0, or 'index' : Drop rows which contain missing values. * 1, or 'columns' : Drop columns which contain missing value.
how
{'any', 'all'}, default 'any'
Determine if row or column is removed from DataFrame, when we have at least one NA or all NA. * 'any' : If any NA values are present, drop that row or column. * 'all' : If all values are NA, drop that row or column.
ignore_index
bool, default False
If True
, the resulting axis will be labeled 0, 1, …, n - 1.
bigframes.dataframe.DataFrame
duplicated
duplicated
(
subset
=
None
,
keep
:
str
=
"first"
)
-
> bigframes
.
series
.
Series
Return boolean Series denoting duplicate rows.
Considering certain columns is optional.
subset
column label or sequence of labels, optional
Only consider certain columns for identifying duplicates, by default use all of the columns.
keep
{'first', 'last', False}, default 'first'
Determines which duplicates (if any) to mark. - first
: Mark duplicates as True
except for the first occurrence. - last
: Mark duplicates as True
except for the last occurrence. - False : Mark all duplicates as True
.
eq
eq
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get equal to of DataFrame and other, element-wise (binary operator eq
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
expanding
expanding
(
min_periods
:
int
=
1
)
-
> bigframes
.
core
.
window
.
Window
Provide expanding window calculations.
min_periods
int, default 1
Minimum number of observations in window required to have a value; otherwise, result is np.nan
.
ffill
ffill
(
*
,
limit
:
typing
.
Optional
[
int
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Fill NA/NaN values by propagating the last valid observation to next valid.
Series/DataFrame or None
fillna
fillna
(
value
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Fill NA/NaN values using the specified method.
value
scalar, Series
Value to use to fill holes (e.g. 0), alternately a Series of values specifying which value to use for each index (for a Series) or column (for a DataFrame). Values not in the Series will not be filled. This value cannot be a list.
DataFrame
filter
filter
(
items
:
typing
.
Optional
[
typing
.
Iterable
]
=
None
,
like
:
typing
.
Optional
[
str
]
=
None
,
regex
:
typing
.
Optional
[
str
]
=
None
,
axis
:
int
|
str
|
None
=
None
,
)
-
> DataFrame
Subset the dataframe rows or columns according to the specified index labels.
Note that this routine does not filter a dataframe on its contents. The filter is applied to the labels of the index.
items
list-like
Keep labels from axis which are in items.
like
str
Keep labels from axis for which "like in label == True".
regex
str (regular expression)
Keep labels from axis for which re.search(regex, label) == True.
axis
{0 or 'index', 1 or 'columns', None}, default None
The axis to filter on, expressed either as an index (int) or axis name (str). By default this is the info axis, 'columns' for DataFrame. For Series
this parameter is unused and defaults to None
.
first_valid_index
first_valid_index
()
API documentation for first_valid_index
method.
floordiv
floordiv
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get integer division of DataFrame and other, element-wise (binary operator //
).
Equivalent to dataframe // other
. With reverse version, rfloordiv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
ge
ge
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get 'greater than or equal to' of DataFrame and other, element-wise (binary operator >=
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
DataFrame
get
get
(
key
,
default
=
None
)
Get item from object for given key (ex: DataFrame column).
Returns default value if not found.
groupby
groupby
(
by
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
bigframes
.
series
.
Series
,
typing
.
Sequence
[
typing
.
Union
[
typing
.
Hashable
,
bigframes
.
series
.
Series
]],
]
]
=
None
,
*
,
level
:
typing
.
Optional
[
typing
.
Union
[
str
,
int
,
typing
.
Sequence
[
typing
.
Union
[
str
,
int
]]]
]
=
None
,
as_index
:
bool
=
True
,
dropna
:
bool
=
True
)
-
> bigframes
.
core
.
groupby
.
DataFrameGroupBy
Group DataFrame by columns.
A groupby operation involves some combination of splitting the object, applying a function, and combining the results. This can be used to group large amounts of data and compute operations on these groups.
by
str, Sequence[str]
A label or list of labels may be passed to group by the columns in self
. Notice that a tuple is interpreted as a (single) key.
level
int, level name, or sequence of such, default None
If the axis is a MultiIndex (hierarchical), group by a particular level or levels. Do not specify both by
and level
.
as_index
bool, default True
Default True. Return object with group labels as the index. Only relevant for DataFrame input. as_index=False
is effectively "SQL-style" grouped output. This argument has no effect on filtrations such as head()
, tail()
, nth()
and in transformations.
dropna
bool, default True
Default True. If True, and if group keys contain NA values, NA values together with row/column will be dropped. If False, NA values will also be treated as the key in groups.
gt
gt
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get 'greater than' of DataFrame and other, element-wise (binary operator >
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
DataFrame
head
head
(
n
:
int
=
5
)
-
> bigframes
.
dataframe
.
DataFrame
Return the first n
rows.
This function returns the first n
rows for the object based
on position. It is useful for quickly testing if your object
has the right type of data in it.
Not yet supportedFor negative values of n
, this function returns
all rows except the last |n|
rows, equivalent to df[:n]
.
If n is larger than the number of rows, this function returns all rows.
n
int, default 5
Default 5. Number of rows to select.
idxmax
idxmax
()
-
> bigframes
.
series
.
Series
Return index of first occurrence of maximum over requested axis.
NA/null values are excluded.
Series
idxmin
idxmin
()
-
> bigframes
.
series
.
Series
Return index of first occurrence of minimum over requested axis.
NA/null values are excluded.
Series
isin
isin
(
values
)
-
> bigframes
.
dataframe
.
DataFrame
Whether each element in the DataFrame is contained in values.
values
iterable, or dict
The result will only be true at a location if all the labels match. If values
is a dict, the keys must be the column names, which must match.
DataFrame
isna
isna
()
-
> bigframes
.
dataframe
.
DataFrame
Detect missing values.
Return a boolean same-sized object indicating if the values are NA.
NA values get mapped to True values. Everything else gets mapped to
False values. Characters such as empty strings ''
or numpy.inf
are not considered NA values.
isnull
isnull
()
-
> bigframes
.
dataframe
.
DataFrame
Detect missing values.
Return a boolean same-sized object indicating if the values are NA.
NA values get mapped to True values. Everything else gets mapped to
False values. Characters such as empty strings ''
or numpy.inf
are not considered NA values.
items
items
()
Iterate over (column name, Series) pairs.
Iterates over the DataFrame columns, returning a tuple with the column name and the content as a Series.
Iterator
join
join
(
other
:
bigframes
.
dataframe
.
DataFrame
,
*
,
on
:
typing
.
Optional
[
str
]
=
None
,
how
:
str
=
"left"
)
-
> bigframes
.
dataframe
.
DataFrame
Join columns of another DataFrame.
Join columns with other
DataFrame on index
how
{'left', 'right', 'outer', 'inner'}, default 'left'`
How to handle the operation of the two objects. left
: use calling frame's index (or column if on is specified) right
: use other
's index. outer
: form union of calling frame's index (or column if on is specified) with other
's index, and sort it lexicographically. inner
: form intersection of calling frame's index (or column if on is specified) with other
's index, preserving the order of the calling's one.
bigframes.dataframe.DataFrame
other
.kurt
kurt
(
*
,
numeric_only
:
bool
=
False
)
Return unbiased kurtosis over requested axis.
Kurtosis obtained using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.
numeric_only
bool, default False
Include only float, int, boolean columns.
kurtosis
kurtosis
(
*
,
numeric_only
:
bool
=
False
)
Return unbiased kurtosis over requested axis.
Kurtosis obtained using Fisher's definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.
numeric_only
bool, default False
Include only float, int, boolean columns.
le
le
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get 'less than or equal to' of dataframe and other, element-wise (binary operator <=
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
DataFrame
lt
lt
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get 'less than' of DataFrame and other, element-wise (binary operator <
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
DataFrame
map
map
(
func
,
na_action
:
typing
.
Optional
[
str
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Apply a function to a Dataframe elementwise.
This method applies a function that accepts and returns a scalar to every element of a DataFrame.
na_action
Optional[str], default None
{None, 'ignore'}
, default None. If ‘ignore’, propagate NaN values, without passing them to func.
bigframes.dataframe.DataFrame
max
max
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the maximum of the values over the requested axis.
If you want the index
of the maximum, use idxmax
. This is
the equivalent of the numpy.ndarray
method argmax
.
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
mean
mean
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the mean of the values over the requested axis.
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
median
median
(
*
,
numeric_only
:
bool
=
False
,
exact
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the median of the values over the requested axis.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
exact
bool. default False
Default False. Get the exact median instead of an approximate one. Note: exact=True
not yet supported.
merge
merge
(
right
:
bigframes
.
dataframe
.
DataFrame
,
how
:
typing
.
Literal
[
"inner"
,
"left"
,
"outer"
,
"right"
]
=
"inner"
,
on
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
*
,
left_on
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
right_on
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
sort
:
bool
=
False
,
suffixes
:
tuple
[
str
,
str
]
=
(
"_x"
,
"_y"
)
)
-
> bigframes
.
dataframe
.
DataFrame
Merge DataFrame objects with a database-style join.
The join is done on columns or indexes. If joining columns on columns, the DataFrame indexes will be ignored . Otherwise if joining indexes on indexes or indexes on a column or columns, the index will be passed on. When performing a cross merge, no column specifications to merge on are allowed.
on
label or list of labels
Columns to join on. It must be found in both DataFrames. Either on or left_on + right_on must be passed in.
left_on
label or list of labels
Columns to join on in the left DataFrame. Either on or left_on + right_on must be passed in.
right_on
label or list of labels
Columns to join on in the right DataFrame. Either on or left_on + right_on must be passed in.
bigframes.dataframe.DataFrame
min
min
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the minimum of the values over the requested axis.
If you want the index
of the minimum, use idxmin
. This is the
equivalent of the numpy.ndarray
method argmin
.
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool, default False
Default False. Include only float, int, boolean columns.
mod
mod
(
other
:
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get modulo of DataFrame and other, element-wise (binary operator %
).
Equivalent to dataframe % other
. With reverse version, rmod
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
mul
mul
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get multiplication of DataFrame and other, element-wise (binary operator *
).
Equivalent to dataframe * other
. With reverse version, rmul
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
multiply
multiply
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get multiplication of DataFrame and other, element-wise (binary operator *
).
Equivalent to dataframe * other
. With reverse version, rmul
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
ne
ne
(
other
:
typing
.
Any
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get not equal to of DataFrame and other, element-wise (binary operator ne
).
Among flexible wrappers ( eq
, ne
, le
, lt
, ge
, gt
) to comparison
operators.
Equivalent to ==
, !=
, <=
, <
, >=
, >
with support to choose axis
(rows or columns) and level for comparison.
other
scalar, sequence, Series, or DataFrame
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}, default 'columns'
Whether to compare by the index (0 or 'index') or columns (1 or 'columns').
DataFrame
nlargest
nlargest
(
n
:
int
,
columns
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]],
keep
:
str
=
"first"
,
)
-
> bigframes
.
dataframe
.
DataFrame
Return the first n
rows ordered by columns
in descending order.
Return the first n
rows with the largest values in columns
, in
descending order. The columns that are not specified are returned as
well, but not used for ordering.
This method is equivalent to df.sort_values(columns, ascending=False).head(n)
, but more
performant.
n
int
Number of rows to return.
columns
label or list of labels
Column label(s) to order by.
keep
{'first', 'last', 'all'}, default 'first'
Where there are duplicate values: - first
: prioritize the first occurrence(s) - last
: prioritize the last occurrence(s) - all
: do not drop any duplicates, even it means selecting more than n
items.
DataFrame .. note:: This function cannot be used with all column types. For example, when specifying columns with object
or category
dtypes, TypeError
is raised.
n
rows ordered by the given columns in descending order.notna
notna
()
-
> bigframes
.
dataframe
.
DataFrame
Detect existing (non-missing) values.
Return a boolean same-sized object indicating if the values are not NA.
Non-missing values get mapped to True. Characters such as empty
strings ''
or numpy.inf
are not considered NA values.
NA values get mapped to False values.
NDFrame
notnull
notnull
()
-
> bigframes
.
dataframe
.
DataFrame
Detect existing (non-missing) values.
Return a boolean same-sized object indicating if the values are not NA.
Non-missing values get mapped to True. Characters such as empty
strings ''
or numpy.inf
are not considered NA values.
NA values get mapped to False values.
NDFrame
nsmallest
nsmallest
(
n
:
int
,
columns
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]],
keep
:
str
=
"first"
,
)
-
> bigframes
.
dataframe
.
DataFrame
Return the first n
rows ordered by columns
in ascending order.
Return the first n
rows with the smallest values in columns
, in
ascending order. The columns that are not specified are returned as
well, but not used for ordering.
This method is equivalent to df.sort_values(columns, ascending=True).head(n)
, but more
performant.
n
int
Number of rows to return.
columns
label or list of labels
Column label(s) to order by.
keep
{'first', 'last', 'all'}, default 'first'
Where there are duplicate values: - first
: prioritize the first occurrence(s) - last
: prioritize the last occurrence(s) - all
: do not drop any duplicates, even it means selecting more than n
items.
DataFrame .. note:: This function cannot be used with all column types. For example, when specifying columns with object
or category
dtypes, TypeError
is raised.
n
rows ordered by the given columns in ascending order.nunique
nunique
()
-
> bigframes
.
series
.
Series
Count number of distinct elements in specified axis.
pct_change
pct_change
(
periods
:
int
=
1
)
-
> bigframes
.
dataframe
.
DataFrame
Fractional change between the current and a prior element.
Computes the fractional change from the immediately previous row by default. This is useful in comparing the fraction of change in a time series of elements.
periods
int, default 1
Periods to shift for forming percent change.
Series or DataFrame
pivot
pivot
(
*
,
columns
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]],
index
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
values
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Return reshaped DataFrame organized by given index / column values.
Reshape data (produce a "pivot" table) based on column values. Uses
unique values from specified index
/ columns
to form axes of the
resulting DataFrame. This function does not support data
aggregation, multiple values will result in a MultiIndex in the
columns.
columns
str or object or a list of str
Column to use to make new frame's columns.
index
str or object or a list of str, optional
Column to use to make new frame's index. If not given, uses existing index.
values
str, object or a list of the previous, optional
Column(s) to use for populating new frame's values. If not specified, all remaining columns will be used and the result will have hierarchically indexed columns.
pow
pow
(
other
:
int
|
bigframes
.
series
.
Series
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get Exponential power of dataframe and other, element-wise (binary operator pow
).
Equivalent to dataframe ** other
, but with support to substitute a fill_value
for missing data in one of the inputs. With reverse version, rpow
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
prod
prod
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the product of the values over the requested axis.
aßxis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Include only float, int, boolean columns.
product
product
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the product of the values over the requested axis.
aßxis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Include only float, int, boolean columns.
radd
radd
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get addition of DataFrame and other, element-wise (binary operator +
).
Equivalent to dataframe + other
. With reverse version, radd
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rank
rank
(
axis
=
0
,
method
:
str
=
"average"
,
numeric_only
=
False
,
na_option
:
str
=
"keep"
,
ascending
=
True
,
)
-
> bigframes
.
dataframe
.
DataFrame
Compute numerical data ranks (1 through n) along axis.
By default, equal values are assigned a rank that is the average of the ranks of those values.
method
{'average', 'min', 'max', 'first', 'dense'}, default 'average'
How to rank the group of records that have the same value (i.e. ties): average
: average rank of the group, min
: lowest rank in the group max : highest rank in the group,
first : ranks assigned in order they appear in the array,
dense`: like 'min', but rank always increases by 1 between groups.
numeric_only
bool, default False
For DataFrame objects, rank only numeric columns if set to True.
na_option
{'keep', 'top', 'bottom'}, default 'keep'
How to rank NaN values: keep
: assign NaN rank to NaN values, , top
: assign lowest rank to NaN values, bottom
: assign highest rank to NaN values.
ascending
bool, default True
Whether or not the elements should be ranked in ascending order.
same type as caller
rdiv
rdiv
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get floating division of DataFrame and other, element-wise (binary operator /
).
Equivalent to other / dataframe
. With reverse version, truediv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
reindex
reindex
(
labels
=
None
,
*
,
index
=
None
,
columns
=
None
,
axis
:
typing
.
Optional
[
typing
.
Union
[
str
,
int
]]
=
None
,
validate
:
typing
.
Optional
[
bool
]
=
None
)
Conform DataFrame to new index with optional filling logic.
Places NA in locations having no value in the previous index. A new object is produced.
labels
array-like, optional
New labels / index to conform the axis specified by 'axis' to.
index
array-like, optional
New labels for the index. Preferably an Index object to avoid duplicating data.
columns
array-like, optional
New labels for the columns. Preferably an Index object to avoid duplicating data.
axis
int or str, optional
Axis to target. Can be either the axis name ('index', 'columns') or number (0, 1).
DataFrame
reindex_like
reindex_like
(
other
:
bigframes
.
dataframe
.
DataFrame
,
*
,
validate
:
typing
.
Optional
[
bool
]
=
None
)
Return an object with matching indices as other object.
Conform the object to the same index on all axes. Optional filling logic, placing Null in locations having no value in the previous index.
other
Object of the same data type
Its row and column indices are used to define the new indices of this object.
Series or DataFrame
rename
rename
(
*
,
columns
:
typing
.
Mapping
[
typing
.
Hashable
,
typing
.
Hashable
]
)
-
> bigframes
.
dataframe
.
DataFrame
Rename columns.
Dict values must be unique (1-to-1). Labels not contained in a dict will be left as-is. Extra labels listed don't throw an error.
columns
Mapping
Dict-like from old column labels to new column labels.
KeyError
bigframes.dataframe.DataFrame
rename_axis
rename_axis
(
mapper
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]],
**
kwargs
)
-
> bigframes
.
dataframe
.
DataFrame
Set the name of the axis for the index.
bigframes.dataframe.DataFrame
reorder_levels
reorder_levels
(
order
:
LevelsType
,
axis
:
int
|
str
=
0
)
Rearrange index levels using input order. May not drop or duplicate levels.
order
list of int or list of str
List representing new level order. Reference level by number (position) or by key (label).
axis
{0 or 'index', 1 or 'columns'}, default 0
Where to reorder levels.
DataFrame
reset_index
reset_index
(
*
,
drop
:
bool
=
False
)
-
> bigframes
.
dataframe
.
DataFrame
Reset the index.
Reset the index of the DataFrame, and use the default one instead.
drop
bool, default False
Do not try to insert index into dataframe columns. This resets the index to the default integer index.
bigframes.dataframe.DataFrame
rfloordiv
rfloordiv
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get integer division of DataFrame and other, element-wise (binary operator //
).
Equivalent to other // dataframe
. With reverse version, rfloordiv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rmod
rmod
(
other
:
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get modulo of DataFrame and other, element-wise (binary operator %
).
Equivalent to other % dataframe
. With reverse version, mod
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rmul
rmul
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get multiplication of DataFrame and other, element-wise (binary operator *
).
Equivalent to dataframe * other
. With reverse version, rmul
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rolling
rolling
(
window
:
int
,
min_periods
=
None
)
-
> bigframes
.
core
.
window
.
Window
Provide rolling window calculations.
window
int, timedelta, str, offset, or BaseIndexer subclass
Size of the moving window. If an integer, the fixed number of observations used for each window. If a timedelta, str, or offset, the time period of each window. Each window will be a variable sized based on the observations included in the time-period. This is only valid for datetime-like indexes. To learn more about the offsets & frequency strings, please see this link https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases
__. If a BaseIndexer subclass, the window boundaries based on the defined get_window_bounds
method. Additional rolling keyword arguments, namely min_periods
, center
, closed
and step
will be passed to get_window_bounds
.
min_periods
int, default None
Minimum number of observations in window required to have a value; otherwise, result is np.nan
. For a window that is specified by an offset, min_periods
will default to 1. For a window that is specified by an integer, min_periods
will default to the size of the window.
Window
subclass if a win_type
is passed. Rolling
subclass if win_type
is not passed.rpow
rpow
(
other
:
int
|
bigframes
.
series
.
Series
,
axis
:
str
|
int
=
"columns"
)
-
> DataFrame
Get Exponential power of dataframe and other, element-wise (binary operator rpow
).
Equivalent to other ** dataframe
, but with support to substitute a fill_value
for missing data in one of the inputs. With reverse version, pow
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rsub
rsub
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get subtraction of DataFrame and other, element-wise (binary operator -
).
Equivalent to other - dataframe
. With reverse version, sub
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
rtruediv
rtruediv
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get floating division of DataFrame and other, element-wise (binary operator /
).
Equivalent to other / dataframe
. With reverse version, truediv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
sample
sample
(
n
:
typing
.
Optional
[
int
]
=
None
,
frac
:
typing
.
Optional
[
float
]
=
None
,
*
,
random_state
:
typing
.
Optional
[
int
]
=
None
)
-
> bigframes
.
dataframe
.
DataFrame
Return a random sample of items from an axis of object.
You can use random_state
for reproducibility.
n
Optional[int], default None
Number of items from axis to return. Cannot be used with frac
. Default = 1 if frac
= None.
frac
Optional[float], default None
Fraction of axis items to return. Cannot be used with n
.
random_state
Optional[int], default None
Seed for random number generator.
set_index
set_index
(
keys
:
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]],
append
:
bool
=
False
,
drop
:
bool
=
True
,
)
-
> bigframes
.
dataframe
.
DataFrame
Set the DataFrame index using existing columns.
Set the DataFrame index (row labels) using one existing column. The index can replace the existing index.
DataFrame
shift
shift
(
periods
:
int
=
1
)
-
> bigframes
.
dataframe
.
DataFrame
Shift index by desired number of periods.
Shifts the index without realigning the data.
NDFrame
skew
skew
(
*
,
numeric_only
:
bool
=
False
)
Return unbiased skew over requested axis.
Normalized by N-1.
numeric_only
bool, default False
Include only float, int, boolean columns.
sort_index
sort_index
(
ascending
:
bool
=
True
,
na_position
:
typing
.
Literal
[
"first"
,
"last"
]
=
"last"
)
-
> bigframes
.
dataframe
.
DataFrame
Sort object by labels (along an axis).
sort_values
sort_values
(
by
:
str
|
typing
.
Sequence
[
str
],
*
,
ascending
:
bool
|
typing
.
Sequence
[
bool
]
=
True
,
kind
:
str
=
"quicksort"
,
na_position
:
typing
.
Literal
[
"first"
,
"last"
]
=
"last"
)
-
> DataFrame
Sort by the values along row axis.
by
str or Sequence[str]
Name or list of names to sort by.
ascending
bool or Sequence[bool], default True
Sort ascending vs. descending. Specify list for multiple sort orders. If this is a list of bools, must match the length of the by.
kind
str, default quicksort
Choice of sorting algorithm. Accepts 'quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’. Ignored except when determining whether to sort stably. 'mergesort' or 'stable' will result in stable reorder.
na_position
{'first', 'last'}, default last
{'first', 'last'}
, default 'last' Puts NaNs at the beginning if first
; last
puts NaNs at the end.
stack
stack
()
Stack the prescribed level(s) from columns to index.
Return a reshaped DataFrame or Series having a multi-level index with one or more new inner-most levels compared to the current DataFrame. The new inner-most levels are created by pivoting the columns of the current dataframe:
- if the columns have a single level, the output is a Series;
- if the columns have multiple levels, the new index level(s) is (are) taken from the prescribed level(s) and the output is a DataFrame.
DataFrame or Series
std
std
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return sample standard deviation over requested axis.
Normalized by N-1 by default.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
sub
sub
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get subtraction of DataFrame and other, element-wise (binary operator -
).
Equivalent to dataframe - other
. With reverse version, rsub
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
subtract
subtract
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get subtraction of DataFrame and other, element-wise (binary operator -
).
Equivalent to dataframe - other
. With reverse version, rsub
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
sum
sum
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return the sum of the values over the requested axis.
This is equivalent to the method numpy.sum
.
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
swaplevel
swaplevel
(
i
:
int
=
-
2
,
j
:
int
=
-
1
,
axis
:
int
|
str
=
0
)
Swap levels i and j in a MultiIndex
.
Default is to swap the two innermost levels of the index.
i
j: int or str
j: Levels of the indices to be swapped. Can pass level name as string.
axis
{0 or 'index', 1 or 'columns'}, default 0
The axis to swap levels on. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
DataFrame
tail
tail
(
n
:
int
=
5
)
-
> bigframes
.
dataframe
.
DataFrame
Return the last n
rows.
This function returns last n
rows from the object based on
position. It is useful for quickly verifying data, for example,
after sorting or appending rows.
For negative values of n
, this function returns all rows except
the first |n|
rows, equivalent to df[|n|:]
.
If n is larger than the number of rows, this function returns all rows.
n
int, default 5
Number of rows to select.
to_csv
to_csv
(
path_or_buf
:
str
,
sep
=
","
,
*
,
header
:
bool
=
True
,
index
:
bool
=
True
)
-
> None
Write object to a comma-separated values (csv) file on Cloud Storage.
path_or_buf
str
A destination URI of Cloud Storage files(s) to store the extracted dataframe in format of gs://<bucket_name>/<object_name_or_glob>
. If the data size is more than 1GB, you must use a wildcard to export the data into multiple files and the size of the files varies. None, file-like objects or local file paths not yet supported.
index
bool, default True
If True, write row names (index).
None
to_dict
to_dict
(
orient
:
Literal
[
'dict'
,
'list'
,
'series'
,
'split'
,
'tight'
,
'records'
,
'index'
]
=
'dict'
,
into
:
type
[
dict
]
=
< class
'
dict
'>, **kwargs) -> dict | list[dict]
Convert the DataFrame to a dictionary.
The type of the key-value pairs can be customized with the parameters (see below).
orient
str {'dict', 'list', 'series', 'split', 'tight', 'records', 'index'}
Determines the type of the values of the dictionary. 'dict' (default) : dict like {column -> {index -> value}}. 'list' : dict like {column -> [values]}. 'series' : dict like {column -> Series(values)}. split' : dict like {'index' -> [index], 'columns' -> [columns], 'data' -> [values]}. 'tight' : dict like {'index' -> [index], 'columns' -> [columns], 'data' -> [values], 'index_names' -> [index.names], 'column_names' -> [column.names]}. 'records' : list like [{column -> value}, ... , {column -> value}]. 'index' : dict like {index -> {column -> value}}.
into
class, default dict
The collections.abc.Mapping subclass used for all Mappings in the return value. Can be the actual class or an empty instance of the mapping type you want. If you want a collections.defaultdict, you must pass it initialized.
index
bool, default True
Whether to include the index item (and index_names item if orient
is 'tight') in the returned dictionary. Can only be False
when orient
is 'split' or 'tight'.
dict or list of dict
orient
parameter.to_excel
to_excel
(
excel_writer
,
sheet_name
:
str
=
"Sheet1"
,
**
kwargs
)
-
> None
Write DataFrame to an Excel sheet.
To write a single DataFrame to an Excel .xlsx file it is only necessary to
specify a target file name. To write to multiple sheets it is necessary to
create an ExcelWriter
object with a target file name, and specify a sheet
in the file to write to.
Multiple sheets may be written to by specifying unique sheet_name
.
With all data written to the file it is necessary to save the changes.
Note that creating an ExcelWriter
object with a file name that already
exists will result in the contents of the existing file being erased.
excel_writer
path-like, file-like, or ExcelWriter object
File path or existing ExcelWriter.
sheet_name
str, default 'Sheet1'
Name of sheet which will contain DataFrame.
to_gbq
to_gbq
(
destination_table
:
str
,
*
,
if_exists
:
typing
.
Optional
[
typing
.
Literal
[
"fail"
,
"replace"
,
"append"
]]
=
"fail"
,
index
:
bool
=
True
,
ordering_id
:
typing
.
Optional
[
str
]
=
None
)
-
> None
Write a DataFrame to a BigQuery table.
destination_table
str
Name of table to be written, in the form dataset.tablename
or project.dataset.tablename
.
if_exists
str, default 'fail'
Behavior when the destination table exists. Value can be one of: 'fail'
If table exists raise pandas_gbq.gbq.TableCreationError. 'replace'
If table exists, drop it, recreate it, and insert data. 'append'
If table exists, insert data. Create if does not exist.
index
bool. default True
whether write row names (index) or not.
ordering_id
Optional[str], default None
If set, write the ordering of the DataFrame as a column in the result table with this name.
to_json
to_json
(
path_or_buf
:
str
,
orient
:
typing
.
Literal
[
"split"
,
"records"
,
"index"
,
"columns"
,
"values"
,
"table"
]
=
"columns"
,
*
,
lines
:
bool
=
False
,
index
:
bool
=
True
)
-
> None
Convert the object to a JSON string, written to Cloud Storage.
Note NaN's and None will be converted to null and datetime objects will be converted to UNIX timestamps.
path_or_buf
str
A destination URI of Cloud Storage files(s) to store the extracted dataframe in format of gs://<bucket_name>/<object_name_or_glob>
. Must contain a wildcard *
character. If the data size is more than 1GB, you must use a wildcard to export the data into multiple files and the size of the files varies. None, file-like objects or local file paths not yet supported.
orient
{ split
, records
, index
, columns
, values
, table
}, default 'columns
Indication of expected JSON string format. * Series: - default is 'index' - allowed values are: {{'split', 'records', 'index', 'table'}}. * DataFrame: - default is 'columns' - allowed values are: {{'split', 'records', 'index', 'columns', 'values', 'table'}}. * The format of the JSON string: - 'split' : dict like {{'index' -> [index], 'columns' -> [columns], 'data' -> [values]}} - 'records' : list like [{{column -> value}}, ... , {{column -> value}}] - 'index' : dict like {{index -> {{column -> value}}}} - 'columns' : dict like {{column -> {{index -> value}}}} - 'values' : just the values array - 'table' : dict like {{'schema': {{schema}}, 'data': {{data}}}} Describing the data, where data component is like orient='records'
.
index
bool, default True
If True, write row names (index).
lines
bool, default False
If 'orient' is 'records' write out line-delimited json format. Will throw ValueError if incorrect 'orient' since others are not list-like.
None
to_latex
to_latex
(
buf
=
None
,
columns
:
Sequence
|
None
=
None
,
header
:
bool
|
Sequence
[
str
]
=
True
,
index
:
bool
=
True
,
**
kwargs
)
-
> str
|
None
Render object to a LaTeX tabular, longtable, or nested table.
Requires \usepackage{{booktabs}}
. The output can be copy/pasted
into a main LaTeX document or read from an external file
with \input{{table.tex}}
.
buf
str, Path or StringIO-like, optional, default None
Buffer to write to. If None, the output is returned as a string.
columns
list of label, optional
The subset of columns to write. Writes all columns by default.
header
bool or list of str, default True
Write out the column names. If a list of strings is given, it is assumed to be aliases for the column names.
index
bool, default True
Write row names (index).
to_markdown
to_markdown
(
buf
=
None
,
mode
:
str
=
"wt"
,
index
:
bool
=
True
,
**
kwargs
)
-
> str
|
None
Print DataFrame in Markdown-friendly format.
buf
str, Path or StringIO-like, optional, default None
Buffer to write to. If None, the output is returned as a string.
mode
str, optional
Mode in which file is opened.
index
bool, optional, default True
Add index (row) labels.
to_numpy
to_numpy
(
dtype
=
None
,
copy
=
False
,
na_value
=
None
,
**
kwargs
)
-
> numpy
.
ndarray
Convert the DataFrame to a NumPy array.
dtype
None
The dtype to pass to numpy.asarray()
.
copy
bool, default None
Whether to ensure that the returned value is not a view on another array.
na_value
Any, default None
The value to use for missing values. The default value depends on dtype and the dtypes of the DataFrame columns.
numpy.ndarray
to_orc
to_orc
(
path
=
None
,
**
kwargs
)
-
> bytes
|
None
Write a DataFrame to the ORC format.
path
str, file-like object or None, default None
If a string, it will be used as Root Directory path when writing a partitioned dataset. By file-like object, we refer to objects with a write() method, such as a file handle (e.g. via builtin open function). If path is None, a bytes object is returned.
to_pandas
to_pandas
(
max_download_size
:
typing
.
Optional
[
int
]
=
None
,
sampling_method
:
typing
.
Optional
[
str
]
=
None
,
random_state
:
typing
.
Optional
[
int
]
=
None
,
)
-
> pandas
.
core
.
frame
.
DataFrame
Write DataFrame to pandas DataFrame.
max_download_size
int, default None
Download size threshold in MB. If max_download_size is exceeded when downloading data (e.g., to_pandas()), the data will be downsampled if bigframes.options .sampling.enable_downsampling is True, otherwise, an error will be raised. If set to a value other than None, this will supersede the global config.
sampling_method
str, default None
Downsampling algorithms to be chosen from, the choices are: "head": This algorithm returns a portion of the data from the beginning. It is fast and requires minimal computations to perform the downsampling; "uniform": This algorithm returns uniform random samples of the data. If set to a value other than None, this will supersede the global config.
random_state
int, default None
The seed for the uniform downsampling algorithm. If provided, the uniform method may take longer to execute and require more computation. If set to a value other than None, this will supersede the global config.
pandas.DataFrame
to_parquet
to_parquet
(
path
:
str
,
*
,
index
:
bool
=
True
)
-
> None
Write a DataFrame to the binary Parquet format.
This function writes the dataframe as a parquet file
<https://parquet.apache.org/>
_ to Cloud Storage.
path
str
Destination URI(s) of Cloud Storage files(s) to store the extracted dataframe in format of gs://<bucket_name>/<object_name_or_glob>
. If the data size is more than 1GB, you must use a wildcard to export the data into multiple files and the size of the files varies.
index
bool, default True
If True
, include the dataframe's index(es) in the file output. If False
, they will not be written to the file.
to_pickle
to_pickle
(
path
,
**
kwargs
)
-
> None
Pickle (serialize) object to file.
path
str
File path where the pickled object will be stored.
to_records
to_records
(
index
:
bool
=
True
,
column_dtypes
=
None
,
index_dtypes
=
None
)
-
> numpy
.
recarray
Convert DataFrame to a NumPy record array.
Index will be included as the first field of the record array if requested.
index
bool, default True
Include index in resulting record array, stored in 'index' field or using the index label, if set.
column_dtypes
str, type, dict, default None
If a string or type, the data type to store all columns. If a dictionary, a mapping of column names and indices (zero-indexed) to specific data types.
index_dtypes
str, type, dict, default None
If a string or type, the data type to store all index levels. If a dictionary, a mapping of index level names and indices (zero-indexed) to specific data types. This mapping is applied only if index=True
.
np.recarray
to_string
to_string
(
buf
=
None
,
columns
:
Sequence
[
str
]
|
None
=
None
,
col_space
=
None
,
header
:
bool
|
Sequence
[
str
]
=
True
,
index
:
bool
=
True
,
na_rep
:
str
=
"NaN"
,
formatters
=
None
,
float_format
=
None
,
sparsify
:
bool
|
None
=
None
,
index_names
:
bool
=
True
,
justify
:
str
|
None
=
None
,
max_rows
:
int
|
None
=
None
,
max_cols
:
int
|
None
=
None
,
show_dimensions
:
bool
=
False
,
decimal
:
str
=
"."
,
line_width
:
int
|
None
=
None
,
min_rows
:
int
|
None
=
None
,
max_colwidth
:
int
|
None
=
None
,
encoding
:
str
|
None
=
None
,
)
-
> str
|
None
Render a DataFrame to a console-friendly tabular output.
buf
str, Path or StringIO-like, optional, default None
Buffer to write to. If None, the output is returned as a string.
columns
sequence, optional, default None
The subset of columns to write. Writes all columns by default.
col_space
int, list or dict of int, optional
The minimum width of each column.
header
bool or sequence, optional
Write out the column names. If a list of strings is given, it is assumed to be aliases for the column names.
index
bool, optional, default True
Whether to print index (row) labels.
na_rep
str, optional, default 'NaN'
String representation of NAN to use.
formatters
list, tuple or dict of one-param. functions, optional
Formatter functions to apply to columns' elements by position or name. The result of each function must be a unicode string. List/tuple must be of length equal to the number of columns.
float_format
one-parameter function, optional, default None
Formatter function to apply to columns' elements if they are floats. The result of this function must be a unicode string.
sparsify
bool, optional, default True
Set to False for a DataFrame with a hierarchical index to print every multiindex key at each row.
index_names
bool, optional, default True
Prints the names of the indexes.
justify
str, default None
How to justify the column labels. If None uses the option from the print configuration (controlled by set_option), 'right' out of the box. Valid values are, 'left', 'right', 'center', 'justify', 'justify-all', 'start', 'end', 'inherit', 'match-parent', 'initial', 'unset'.
max_rows
int, optional
Maximum number of rows to display in the console.
min_rows
int, optional
The number of rows to display in the console in a truncated repr (when number of rows is above max_rows
).
max_cols
int, optional
Maximum number of columns to display in the console.
show_dimensions
bool, default False
Display DataFrame dimensions (number of rows by number of columns).
decimal
str, default '.'
Character recognized as decimal separator, e.g. ',' in Europe.
line_width
int, optional
Width to wrap a line in characters.
max_colwidth
int, optional
Max width to truncate each column in characters. By default, no limit.
encoding
str, default "utf-8"
Set character encoding.
str or None
truediv
truediv
(
other
:
float
|
int
|
bigframes
.
series
.
Series
|
DataFrame
,
axis
:
str
|
int
=
"columns"
,
)
-
> DataFrame
Get floating division of DataFrame and other, element-wise (binary operator /
).
Equivalent to dataframe / other
. With reverse version, rtruediv
.
Among flexible wrappers ( add
, sub
, mul
, div
, mod
, pow
) to
arithmetic operators: +
, -
, *
, /
, //
, %
, **
.
other
float, int, or Series
Any single or multiple element data structure, or list-like object.
axis
{0 or 'index', 1 or 'columns'}
Whether to compare by the index (0 or 'index') or columns. (1 or 'columns'). For Series input, axis to match Series index on.
DataFrame
unstack
unstack
()
Pivot a level of the (necessarily hierarchical) index labels.
Returns a DataFrame having a new level of column labels whose inner-most level consists of the pivoted index labels.
If the index is not a MultiIndex, the output will be a Series (the analogue of stack when the columns are not a MultiIndex).
update
update
(
other
,
join
:
str
=
"left"
,
overwrite
=
True
,
filter_func
=
None
)
Modify in place using non-NA values from another DataFrame.
Aligns on indices. There is no return value.
other
DataFrame, or object coercible into a DataFrame
Should have at least one matching index/column label with the original DataFrame. If a Series is passed, its name attribute must be set, and that will be used as the column name to align with the original DataFrame.
join
{'left'}, default 'left'
Only left join is implemented, keeping the index and columns of the original object.
overwrite
bool, default True
How to handle non-NA values for overlapping keys: True: overwrite original DataFrame's values with values from other
. False: only update values that are NA in the original DataFrame.
filter_func
callable(1d-array) -> bool 1d-array, optional
Can choose to replace values other than NA. Return True for values that should be updated.
None
value_counts
value_counts
(
subset
:
typing
.
Optional
[
typing
.
Union
[
typing
.
Hashable
,
typing
.
Sequence
[
typing
.
Hashable
]]
]
=
None
,
normalize
:
bool
=
False
,
sort
:
bool
=
True
,
ascending
:
bool
=
False
,
dropna
:
bool
=
True
,
)
Return a Series containing counts of unique rows in the DataFrame.
subset
label or list of labels, optional
Columns to use when counting unique combinations.
normalize
bool, default False
Return proportions rather than frequencies.
sort
bool, default True
Sort by frequencies.
ascending
bool, default False
Sort in ascending order.
dropna
bool, default True
Don’t include counts of rows that contain NA values.
Series
var
var
(
axis
:
typing
.
Union
[
str
,
int
]
=
0
,
*
,
numeric_only
:
bool
=
False
)
-
> bigframes
.
series
.
Series
Return unbiased variance over requested axis.
Normalized by N-1 by default.
axis
{index (0), columns (1)}
Axis for the function to be applied on. For Series this parameter is unused and defaults to 0.
numeric_only
bool. default False
Default False. Include only float, int, boolean columns.
