Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://cloud.google.com/python/docs/reference/bigframes/0.12.0/bigframes.series.Series below:

Class Series (0.12.0) | Python client library

Stay organized with collections Save and categorize content based on your preferences.

• 2.15.0 (latest)
• 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.1.0
• 2.0.0
• 1.42.0
• 1.41.0
• 1.40.0
• 1.39.0
• 1.38.0
• 1.37.0
• 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

N-dimensional analogue of DataFrame. Store multi-dimensional in a size-mutable, labeled data structure

Return the transpose, which is by definition self.

Access a single value for a row/column label pair.

Accessor object for datetime-like properties of the Series values.

Return the dtype object of the underlying data.

Return the dtype object of the underlying data.

Indicates whether Series/DataFrame is empty.

True if Series/DataFrame is entirely empty (no items), meaning any of the axes are of length 0.

Access a single value for a row/column pair by integer position.

Purely integer-location based indexing for selection by position.

The index (axis labels) of the Series.

Return boolean if values in the object are monotonically decreasing.

Return boolean if values in the object are monotonically increasing.

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. 5 or 'a', (note that 5 is interpreted as a label of the index, and never as an integer position along the index).
• A list 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 yet An alignable boolean Series. The index of the key will be aligned before masking.
• Not supported yet A slice object with labels, e.g. 'a':'f'. Note: contrary to usual python slices, both the start and the stop are included.
• Not supported yet A callable function with one argument (the calling Series or DataFrame) that returns valid output for indexing (one of the above).

Return the name of the Series.

The name of a Series becomes its index or column name if it is used to form a DataFrame. It is also used whenever displaying the Series using the interpreter.

Return an int representing the number of axes / array dimensions.

BigQuery job metadata for the most recent query.

Return a tuple of the shape of the underlying data.

Return an int representing the number of elements in this object.

Vectorized string functions for Series and Index.

NAs stay NA unless handled otherwise by a particular method. Patterned after Python’s string methods, with some inspiration from R’s stringr package.

Accessor object for struct properties of the Series values.

API documentation for values property.

__array_ufunc__(
    ufunc: numpy.ufunc, method: str, *inputs, **kwargs
) -> bigframes.series.Series

Used to support numpy ufuncs. See: https://numpy.org/doc/stable/reference/ufuncs.html

Matrix multiplication using binary @ operator in Python>=3.5.

abs() -> bigframes.series.Series

Return a Series/DataFrame with absolute numeric value of each element.

This function only applies to elements that are all numeric.

add(other: float | int | Series) -> Series

Return addition of Series and other, element-wise (binary operator add).

Equivalent to series + other, but with support to substitute a fill_value for missing data in either one of the inputs.

add_prefix(prefix: str, axis: int | str | None = None) -> Series

Prefix labels with string prefix.

For Series, the row labels are prefixed. For DataFrame, the column labels are prefixed.

The string to add before each label.

{{0 or 'index', 1 or 'columns', None}}, default None. Axis to add prefix on.

add_suffix(suffix: str, axis: int | str | None = None) -> Series

Suffix labels with string suffix.

For Series, the row labels are suffixed. For DataFrame, the column labels are suffixed.

agg(func: str | typing.Sequence[str]) -> scalars.Scalar | Series

Aggregate using one or more operations over the specified axis.

Function to use for aggregating the data. Accepted combinations are: string function name, list of function names, e.g. ['sum', 'mean'].

aggregate(func: str | typing.Sequence[str]) -> scalars.Scalar | Series

Aggregate using one or more operations over the specified axis.

Function to use for aggregating the data. Accepted combinations are: string function name, list of function names, e.g. ['sum', 'mean'].

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).

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).

apply(func) -> bigframes.series.Series

Invoke function on values of Series.

Can be ufunc (a NumPy function that applies to the entire Series) or a Python function that only works on single values.

Python function or NumPy ufunc to apply.

Return int position of the smallest value in the Series.

If the minimum is achieved in multiple locations, the first row position is returned.

Return int position of the largest value in the Series.

If the maximum is achieved in multiple locations, the first row position is returned.

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.series.Series

Cast a pandas object to a specified dtype dtype.

A dtype supported by BigQuery DataFrame include 'boolean','Float64','Int64', 'string', 'tring[pyarrow]','timestamp[us, tz=UTC][pyarrow]', 'timestampus][pyarrow]','date32day][pyarrow]','time64us][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")).

between(left, right, inclusive="both")

Return boolean Series equivalent to left <= series <= right.

This function returns a boolean vector containing True wherever the corresponding Series element is between the boundary values left and right. NA values are treated as False.

Left boundary.

Right boundary.

Include boundaries. Whether to set each bound as closed or open.

bfill(*, limit: typing.Optional[int] = None) -> bigframes.series.Series

Fill NA/NaN values by using the next valid observation to fill the gap.

Trim values at input threshold(s).

Assigns values outside boundary to boundary values. Thresholds can be singular values or array like, and in the latter case the clipping is performed element-wise in the specified axis.

Minimum threshold value. All values below this threshold will be set to it. A missing threshold (e.g NA) will not clip the value.

Maximum threshold value. All values above this threshold will be set to it. A missing threshold (e.g NA) will not clip the value.

copy() -> bigframes.series.Series

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.

corr(other: bigframes.series.Series, method="pearson", min_periods=None) -> float

Compute the correlation with the other Series. Non-number values are ignored in the computation.

Uses the "Pearson" method of correlation. Numbers are converted to float before calculation, so the result may be unstable.

The series with which this is to be correlated.

Correlation method to use - currently only "pearson" is supported.

The minimum number of observations needed to return a result. Non-default values are not yet supported, so a result will be returned for at least two observations.

Return number of non-NA/null observations in the Series.

cummax() -> bigframes.series.Series

Return cumulative maximum over a DataFrame or Series axis.

Returns a DataFrame or Series of the same size containing the cumulative maximum.

The index or the name of the axis. 0 is equivalent to None or 'index'. For Series this parameter is unused and defaults to 0.

cummin() -> bigframes.series.Series

Return cumulative minimum over a DataFrame or Series axis.

Returns a DataFrame or Series of the same size containing the cumulative minimum.

The index or the name of the axis. 0 is equivalent to None or 'index'. For Series this parameter is unused and defaults to 0.

Exclude NA/null values. If an entire row/column is NA, the result will be NA.

cumprod() -> bigframes.series.Series

Return cumulative product over a DataFrame or Series axis.

Returns a DataFrame or Series of the same size containing the cumulative product.

cumsum() -> bigframes.series.Series

Return cumulative sum over a DataFrame or Series axis.

Returns a DataFrame or Series of the same size containing the cumulative sum.

The index or the name of the axis. 0 is equivalent to None or 'index'. For Series this parameter is unused and defaults to 0.

diff(periods: int = 1) -> bigframes.series.Series

First discrete difference of element.

Calculates the difference of a {klass} element compared with another element in the {klass} (default is element in previous row).

Periods to shift for calculating difference, accepts negative values.

div(other: float | int | Series) -> Series

Return floating division of Series and other, element-wise (binary operator truediv).

Equivalent to series / other, but with support to substitute a fill_value for missing data in either one of the inputs.

divide(other: float | int | Series) -> Series

Return floating division of Series and other, element-wise (binary operator truediv).

Equivalent to series / other, but with support to substitute a fill_value for missing data in either one of the inputs.

divmod(other) -> typing.Tuple[bigframes.series.Series, bigframes.series.Series]

Return integer division and modulo of Series and other, element-wise (binary operator divmod).

Equivalent to divmod(series, other).

Compute the dot product between the Series and the columns of other.

This method computes the dot product between the Series and another one, or the Series and each columns of a DataFrame, or the Series and each columns of an array.

It can also be called using self @ other in Python >= 3.5.

The other object to compute the dot product with its columns.

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.Iterable[typing.Hashable]]
    ] = None,
    level: typing.Optional[typing.Union[str, int]] = None
) -> bigframes.series.Series

Return Series with specified index labels removed.

Remove elements of a Series based on specifying the index labels. When using a multi-index, labels on different levels can be removed by specifying the level.

Index labels to drop.

drop_duplicates(*, keep: str = "first") -> bigframes.series.Series

Return Series with duplicate values removed.

Method to handle dropping duplicates: 'first' : Drop duplicates except for the first occurrence. 'last' : Drop duplicates except for the last occurrence. False : Drop all duplicates.

droplevel(level: LevelsType, axis: int | str = 0)

Return Series with requested index / column level(s) removed.

If a string is given, must be the name of a level If list-like, elements must be names or positional indexes of levels.

For Series this parameter is unused and defaults to 0.

dropna(
    *,
    axis: int = 0,
    inplace: bool = False,
    how: typing.Optional[str] = None,
    ignore_index: bool = False
) -> bigframes.series.Series

Return a new Series with missing values removed.

Unused. Parameter needed for compatibility with DataFrame.

Unsupported, do not set.

Not in use. Kept for compatibility.

duplicated(keep: str = "first") -> bigframes.series.Series

Indicate duplicate Series values.

Duplicated values are indicated as True values in the resulting Series. Either all duplicates, all except the first or all except the last occurrence of duplicates can be indicated.

Method to handle dropping duplicates: '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(other: object) -> bigframes.series.Series

Return equal of Series and other, element-wise (binary operator eq).

Equivalent to other == series, but with support to substitute a fill_value for missing data in either one of the inputs.

equals(
    other: typing.Union[bigframes.series.Series, bigframes.dataframe.DataFrame]
) -> bool

API documentation for equals method.

expanding(min_periods: int = 1) -> bigframes.core.window.Window

Provide expanding window calculations.

Minimum number of observations in window required to have a value; otherwise, result is np.nan.

ffill(*, limit: typing.Optional[int] = None) -> bigframes.series.Series

Fill NA/NaN values by propagating the last valid observation to next valid.

fillna(value=None) -> bigframes.series.Series

Fill NA/NaN values using the specified method.

Value to use to fill holes (e.g. 0).

filter(
    items: typing.Optional[typing.Iterable] = None,
    like: typing.Optional[str] = None,
    regex: typing.Optional[str] = None,
    axis: typing.Optional[typing.Union[str, int]] = None,
) -> bigframes.series.Series

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.

Keep labels from axis which are in items.

Keep labels from axis for which "like in label == True".

Keep labels from axis for which re.search(regex, label) == True.

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.

floordiv(other: float | int | Series) -> Series

Return integer division of Series and other, element-wise (binary operator floordiv).

Equivalent to series // other, but with support to substitute a fill_value for missing data in either one of the inputs.

ge(other) -> bigframes.series.Series

Get 'greater than or equal to' of Series and other, element-wise (binary operator >=).

Equivalent to series >= other, but with support to substitute a fill_value for missing data in either one of the inputs.

Get item from object for given key (ex: DataFrame column).

Returns default value if not found.

groupby(
    by: typing.Union[
        blocks.Label, Series, typing.Sequence[typing.Union[blocks.Label, Series]]
    ] = None,
    axis=0,
    level: typing.Optional[
        int | str | typing.Sequence[int] | typing.Sequence[str]
    ] = None,
    as_index: bool = True,
    *,
    dropna: bool = True
) -> bigframes.core.groupby.SeriesGroupBy

Group Series using a mapper or by a Series of 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.

Used to determine the groups for the groupby. If by is a function, it's called on each value of the object's index. If a dict or Series is passed, the Series or dict VALUES will be used to determine the groups (the Series' values are first aligned; see .align() method). If a list or ndarray of length equal to the selected axis is passed (see the groupby user guide https://pandas.pydata.org/pandas-docs/stable/user_guide/groupby.html#splitting-an-object-into-groups_), the values are used as-is to determine the groups. 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.

Split along rows (0) or columns (1). For Series this parameter is unused and defaults to 0.

If the axis is a MultiIndex (hierarchical), group by a particular level or levels. Do not specify both by and level.

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 (see the "filtrations in the user guide" https://pandas.pydata.org/docs/dev/user_guide/groupby.html#filtration), such as head(), tail(), nth() and in transformations (see the "transformations in the user guide" https://pandas.pydata.org/docs/dev/user_guide/groupby.html#transformation).

gt(other) -> bigframes.series.Series

Get 'less than or equal to' of Series and other, element-wise (binary operator <=).

Equivalent to series <= other, but with support to substitute a fill_value for missing data in either one of the inputs.

head(n: int = 5) -> bigframes.series.Series

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 supported For 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.

Default 5. Number of rows to select.

idxmax() -> typing.Hashable

Return the row label of the maximum value.

If multiple values equal the maximum, the first row label with that value is returned.

idxmin() -> typing.Hashable

Return the row label of the minimum value.

If multiple values equal the minimum, the first row label with that value is returned.

isin(values) -> "Series" | None

Whether elements in Series are contained in values.

Return a boolean Series showing whether each element in the Series matches an element in the passed sequence of values exactly.

The sequence of values to test. Passing in a single string will raise a TypeError. Instead, turn a single string into a list of one element.

isna() -> bigframes.series.Series

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() -> bigframes.series.Series

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.

Return unbiased kurtosis over requested axis.

Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.

Return unbiased kurtosis over requested axis.

Kurtosis obtained using Fisher’s definition of kurtosis (kurtosis of normal == 0.0). Normalized by N-1.

le(other) -> bigframes.series.Series

Get 'less than or equal to' of Series and other, element-wise (binary operator <=).

Equivalent to series <= other, but with support to substitute a fill_value for missing data in either one of the inputs.

lt(other) -> bigframes.series.Series

Get 'less than' of Series and other, element-wise (binary operator <).

Equivalent to series < other, but with support to substitute a fill_value for missing data in either one of the inputs.

map(
    arg: typing.Union[typing.Mapping, bigframes.series.Series],
    na_action: typing.Optional[str] = None,
    *,
    verify_integrity: bool = False
) -> bigframes.series.Series

Map values of Series according to an input mapping or function.

Used for substituting each value in a Series with another value, that may be derived from a remote function, dict, or a Series.

If arg is a remote function, the overhead for remote functions applies. If mapping with a dict, fully deferred computation is possible. If mapping with a Series, fully deferred computation is only possible if verify_integrity=False.

remote function, collections.abc.Mapping subclass or Series Mapping correspondence.

mask(cond, other=None) -> bigframes.series.Series

Replace values where the condition is True.

Where cond is False, keep the original value. Where True, replace with corresponding value from other. If cond is callable, it is computed on the Series/DataFrame and should return boolean Series/DataFrame or array. The callable must not change input Series/DataFrame (though pandas doesn’t check it).

Entries where cond is True are replaced with corresponding value from other. If other is callable, it is computed on the Series/DataFrame and should return scalar or Series/DataFrame. The callable must not change input Series/DataFrame (though pandas doesn’t check it). If not specified, entries will be filled with the corresponding NULL value (np.nan for numpy dtypes, pd.NA for extension dtypes).

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.

Return the mean of the values over the requested axis.

median(*, exact: bool = False) -> float

Return the median of the values over the requested axis.

Default False. Get the exact median instead of an approximate one. Note: exact=True not yet supported.

Return the maximum 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.

mod(other) -> bigframes.series.Series

Return modulo of Series and other, element-wise (binary operator mod).

Equivalent to series % other, but with support to substitute a fill_value for missing data in either one of the inputs.

mode() -> bigframes.series.Series

Return the mode(s) of the Series.

The mode is the value that appears most often. There can be multiple modes.

Always returns Series even if only one value is returned.

mul(other: float | int | Series) -> Series

Return multiplication of Series and other, element-wise (binary operator mul).

Equivalent to other * series, but with support to substitute a fill_value for missing data in either one of the inputs.

multiply(other: float | int | Series) -> Series

Return multiplication of Series and other, element-wise (binary operator mul).

Equivalent to other * series, but with support to substitute a fill_value for missing data in either one of the inputs.

ne(other: object) -> bigframes.series.Series

Return not equal of Series and other, element-wise (binary operator ne).

Equivalent to other != series, but with support to substitute a fill_value for missing data in either one of the inputs.

nlargest(n: int = 5, keep: str = "first") -> bigframes.series.Series

Return the largest n elements.

Return this many descending sorted values.

When there are duplicate values that cannot all fit in a Series of n elements: first : return the first n occurrences in order of appearance. last : return the last n occurrences in reverse order of appearance. all : keep all occurrences. This can result in a Series of size larger than n.

notna() -> bigframes.series.Series

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.

notnull() -> bigframes.series.Series

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.

nsmallest(n: int = 5, keep: str = "first") -> bigframes.series.Series

Return the smallest n elements.

Return this many ascending sorted values.

When there are duplicate values that cannot all fit in a Series of n elements: first : return the first n occurrences in order of appearance. last : return the last n occurrences in reverse order of appearance. all : keep all occurrences. This can result in a Series of size larger than n.

Return number of unique elements in the object.

Excludes NA values by default.

pad(*, limit: typing.Optional[int] = None) -> bigframes.series.Series

Fill NA/NaN values by propagating the last valid observation to next valid.

pct_change(periods: int = 1) -> bigframes.series.Series

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 to shift for forming percent change.

pow(other: float | int | Series) -> Series

Return Exponential power of series and other, element-wise (binary operator pow).

Equivalent to series ** other, but with support to substitute a fill_value for missing data in either one of the inputs.

Return the product of the values over the requested axis.

Return the product of the values over the requested axis.

radd(other: float | int | Series) -> Series

Return addition of Series and other, element-wise (binary operator radd).

Equivalent to other + series, but with support to substitute a fill_value for missing data in either one of the inputs.

rank(
    axis=0,
    method: str = "average",
    numeric_only=False,
    na_option: str = "keep",
    ascending: bool = True,
) -> bigframes.series.Series

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.

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.

For DataFrame objects, rank only numeric columns if set to True.

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.

Whether or not the elements should be ranked in ascending order.

rdiv(other: float | int | Series) -> Series

Return floating division of Series and other, element-wise (binary operator rtruediv).

Equivalent to other / series, but with support to substitute a fill_value for missing data in either one of the inputs.

rdivmod(other) -> typing.Tuple[bigframes.series.Series, bigframes.series.Series]

Return integer division and modulo of Series and other, element-wise (binary operator rdivmod).

Equivalent to other divmod series.

reindex(index=None, *, validate: typing.Optional[bool] = None)

Conform Series to new index with optional filling logic.

Places NA/NaN in locations having no value in the previous index. A new object is produced unless the new index is equivalent to the current one and copy=False.

New labels for the index. Preferably an Index object to avoid duplicating data.

reindex_like(
    other: bigframes.series.Series, *, 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.

Its row and column indices are used to define the new indices of this object.

rename(
    index: typing.Optional[
        typing.Union[typing.Hashable, typing.Mapping[typing.Any, typing.Any]]
    ] = None,
    **kwargs
) -> bigframes.series.Series

Alter Series index labels or name.

Function / dict values must be unique (1-to-1). Labels not contained in a dict / Series will be left as-is. Extra labels listed don't throw an error.

Alternatively, change Series.name with a scalar value.

Functions or dict-like are transformations to apply to the index. Scalar or hashable sequence-like will alter the Series.name attribute.

rename_axis(
    mapper: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]], **kwargs
) -> bigframes.series.Series

Set the name of the axis for the index or columns.

Value to set the axis name attribute.

reorder_levels(order: LevelsType, axis: int | str = 0)

Rearrange index levels using input order.

May not drop or duplicate levels.

Reference level by number or key.

For Series this parameter is unused and defaults to 0.

replace(
    to_replace: typing.Any,
    value: typing.Optional[typing.Any] = None,
    *,
    regex: bool = False
)

Replace values given in to_replace with value.

Values of the Series/DataFrame are replaced with other values dynamically. This differs from updating with .loc or .iloc, which require you to specify a location to update with some value.

How to find the values that will be replaced. * numeric, str or regex: - numeric: numeric values equal to to_replace will be replaced with value - str: string exactly matching to_replace will be replaced with value - regex: regexs matching to_replace will be replaced with value * list of str, regex, or numeric: - First, if to_replace and value are both lists, they must be the same length. - Second, if regex=True then all of the strings in both lists will be interpreted as regexs otherwise they will match directly. This doesn't matter much for value since there are only a few possible substitution regexes you can use. - str, regex and numeric rules apply as above.

Value to replace any values matching to_replace with. For a DataFrame a dict of values can be used to specify which value to use for each column (columns not in the dict will not be filled). Regular expressions, strings and lists or dicts of such objects are also allowed.

Whether to interpret to_replace and/or value as regular expressions. If this is True then to_replace must be a string.

reset_index(
    *, name: typing.Optional[str] = None, drop: bool = False
) -> bigframes.dataframe.DataFrame | Series

Generate a new DataFrame or Series with the index reset.

This is useful when the index needs to be treated as a column, or when the index is meaningless and needs to be reset to the default before another operation.

Just reset the index, without inserting it as a column in the new DataFrame.

The name to use for the column containing the original Series values. Uses self.name by default. This argument is ignored when drop is True.

rfloordiv(other: float | int | Series) -> Series

Return integer division of Series and other, element-wise (binary operator rfloordiv).

Equivalent to other // series, but with support to substitute a fill_value for missing data in either one of the inputs.

rmod(other) -> bigframes.series.Series

Return modulo of Series and other, element-wise (binary operator mod).

Equivalent to series % other, but with support to substitute a fill_value for missing data in either one of the inputs.

rmul(other: float | int | Series) -> Series

Return multiplication of Series and other, element-wise (binary operator mul).

Equivalent to series * others, but with support to substitute a fill_value for missing data in either one of the inputs.

rolling(window: int, min_periods=None) -> bigframes.core.window.Window

Provide rolling window calculations.

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.

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.

round(decimals=0) -> bigframes.series.Series

Round each value in a Series to the given number of decimals.

Number of decimal places to round to. If decimals is negative, it specifies the number of positions to the left of the decimal point.

rpow(other: float | int | Series) -> Series

Return Exponential power of series and other, element-wise (binary operator rpow).

Equivalent to other ** series, but with support to substitute a fill_value for missing data in either one of the inputs.

rsub(other: float | int | Series) -> Series

Return subtraction of Series and other, element-wise (binary operator rsub).

Equivalent to other - series, but with support to substitute a fill_value for missing data in either one of the inputs.

rtruediv(other: float | int | Series) -> Series

Return floating division of Series and other, element-wise (binary operator rtruediv).

Equivalent to other / series, but with support to substitute a fill_value for missing data in either one of the inputs.

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None
)

Return a random sample of items from an axis of object.

You can use random_state for reproducibility.

Number of items from axis to return. Cannot be used with frac. Default = 1 if frac = None.

Fraction of axis items to return. Cannot be used with n.

Seed for random number generator.

shift(periods: int = 1) -> bigframes.series.Series

Shift index by desired number of periods.

Shifts the index without realigning the data.

Return unbiased skew over requested axis.

Normalized by N-1.

sort_index(
    *, axis=0, ascending=True, na_position="last"
) -> bigframes.series.Series

Sort Series by index labels.

Returns a new Series sorted by label if inplace argument is False, otherwise updates the original series and returns None.

Unused. Parameter needed for compatibility with DataFrame.

Sort ascending vs. descending. When the index is a MultiIndex the sort direction can be controlled for each level individually.

If 'first' puts NaNs at the beginning, 'last' puts NaNs at the end. Not implemented for MultiIndex.

sort_values(
    *, axis=0, ascending=True, kind: str = "quicksort", na_position="last"
) -> bigframes.series.Series

Sort by the values.

Sort a Series in ascending or descending order by some criterion.

Unused. Parameter needed for compatibility with DataFrame.

If True, sort values in ascending order, otherwise descending.

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

Argument 'first' puts NaNs at the beginning, 'last' puts NaNs at the end.

Return sample standard deviation over requested axis.

Normalized by N-1 by default.

sub(other: float | int | Series) -> Series

Return subtraction of Series and other, element-wise (binary operator sub).

Equivalent to series - other, but with support to substitute a fill_value for missing data in either one of the inputs.

subtract(other: float | int | Series) -> Series

Return subtraction of Series and other, element-wise (binary operator sub).

Equivalent to series - other, but with support to substitute a fill_value for missing data in either one of the inputs.

Return the sum of the values over the requested axis.

This is equivalent to the method numpy.sum.

swaplevel(i: int = -2, j: int = -1)

Swap levels i and j in a MultiIndex.

Default is to swap the two innermost levels of the index.

j: Levels of the indices to be swapped. Can pass level name as string.

tail(n: int = 5) -> bigframes.series.Series

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.

Number of rows to select.

to_csv(path_or_buf=None, **kwargs) -> typing.Optional[str]

Write object to a comma-separated values (csv) file.

String, path object (implementing os.PathLike[str]), or file-like object implementing a write() function. If None, the result is returned as a string. If a non-binary file object is passed, it should be opened with newline='', disabling universal newlines. If a binary file object is passed, mode might need to contain a 'b'.

to_dict(into: type[dict] = <class 'dict'>) -> typing.Mapping

Convert Series to {label -> value} dict or dict-like object.

The collections.abc.Mapping subclass to use as the return object. 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.

to_excel(excel_writer, sheet_name="Sheet1", **kwargs) -> None

Write Series to an Excel sheet.

To write a single Series 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.

File path or existing ExcelWriter.

Name of sheet to contain Series.

to_frame(
    name: typing.Optional[typing.Hashable] = None,
) -> bigframes.dataframe.DataFrame

Convert Series to DataFrame.

The column in the new dataframe will be named name (the keyword parameter) if the name parameter is provided and not None.

to_json(
    path_or_buf=None,
    orient: typing.Literal[
        "split", "records", "index", "columns", "values", "table"
    ] = "columns",
    **kwargs
) -> typing.Optional[str]

Convert the object to a JSON string.

Note NaN's and None will be converted to null and datetime objects will be converted to UNIX timestamps.

String, path object (implementing os.PathLike[str]), or file-like object implementing a write() function. If None, the result is returned as a string.

Indication of expected JSON string format. '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'.

to_latex(
    buf=None, columns=None, header=True, index=True, **kwargs
) -> typing.Optional[str]

Render object to a LaTeX tabular, longtable, or nested table.

Buffer to write to. If None, the output is returned as a string.

The subset of columns to write. Writes all columns by default.

Write out the column names. If a list of strings is given, it is assumed to be aliases for the column names.

Write row names (index).

Return a list of the values.

These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period).

to_markdown(
    buf: typing.IO[str] | None = None, mode: str = "wt", index: bool = True, **kwargs
) -> typing.Optional[str]

Print {klass} in Markdown-friendly format.

Buffer to write to. If None, the output is returned as a string.

Mode in which file is opened, "wt" by default.

Add index (row) labels.

to_numpy(dtype=None, copy=False, na_value=None, **kwargs) -> numpy.ndarray

A NumPy ndarray representing the values in this Series or Index.

The dtype to pass to numpy.asarray.

Whether to ensure that the returned value is not a view on another array. Note that copy=False does not ensure that to_numpy() is no-copy. Rather, copy=True ensure that a copy is made, even if not strictly necessary.

The value to use for missing values. The default value depends on dtype and the type of the array.

to_pandas(
    max_download_size: typing.Optional[int] = None,
    sampling_method: typing.Optional[str] = None,
    random_state: typing.Optional[int] = None,
) -> pandas.core.series.Series

Writes Series to pandas Series.

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.

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.

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.

to_pickle(path, **kwargs) -> None

Pickle (serialize) object to file.

String, path object (implementing os.PathLike[str]), or file-like object implementing a binary write() function. File path where the pickled object will be stored.

to_string(
    buf=None,
    na_rep="NaN",
    float_format=None,
    header=True,
    index=True,
    length=False,
    dtype=False,
    name=False,
    max_rows=None,
    min_rows=None,
) -> typing.Optional[str]

Render a string representation of the Series.

Buffer to write to.

String representation of NaN to use, default 'NaN'.

Formatter function to apply to columns' elements if they are floats, default None.

Add the Series header (index name).

Add index (row) labels, default True.

Add the Series length.

Add the Series dtype.

Add the Series name if not None.

Maximum number of rows to show before truncating. If None, show all.

The number of rows to display in a truncated repr (when number of rows is above max_rows).

Return an xarray object from the pandas object.

Return a list of the values.

These are each a scalar type, which is a Python scalar (for str, int, float) or a pandas scalar (for Timestamp/Timedelta/Interval/Period).

transpose() -> bigframes.series.Series

Return the transpose, which is by definition self.

truediv(other: float | int | Series) -> Series

Return floating division of Series and other, element-wise (binary operator truediv).

Equivalent to series / other, but with support to substitute a fill_value for missing data in either one of the inputs.

unique() -> bigframes.series.Series

API documentation for unique method.

unstack(
    level: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]] = -1
)

Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.

Level(s) to unstack, can pass level name.

value_counts(
    normalize: bool = False,
    sort: bool = True,
    ascending: bool = False,
    *,
    dropna: bool = True
)

Return a Series containing counts of unique values.

The resulting object will be in descending order so that the first element is the most frequently-occurring element. Excludes NA values by default.

If True then the object returned will contain the relative frequencies of the unique values.

Sort by frequencies.

Sort in ascending order.

Don't include counts of NaN.

Return unbiased variance over requested axis.

Normalized by N-1 by default.

Replace values where the condition is False.

Where cond is True, keep the original value. Where False, replace with corresponding value from other. If cond is callable, it is computed on the Series/DataFrame and returns boolean Series/DataFrame or array. The callable must not change input Series/DataFrame (though pandas doesn’t check it).

Entries where cond is False are replaced with corresponding value from other. If other is callable, it is computed on the Series/DataFrame and returns scalar or Series/DataFrame. The callable must not change input Series/DataFrame (though pandas doesn’t check it). If not specified, entries will be filled with the corresponding NULL value (np.nan for numpy dtypes, pd.NA for extension dtypes).

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2025-08-12 UTC.

[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Hard to understand","hardToUnderstand","thumb-down"],["Incorrect information or sample code","incorrectInformationOrSampleCode","thumb-down"],["Missing the information/samples I need","missingTheInformationSamplesINeed","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2025-08-12 UTC."],[],[]]

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4