Package Methods (2.29.0)

Summary of entries of Methods for bigframes.

bigframes.bigquery.approx_top_count

approx_top_count(
    series: bigframes.series.Series, number: int
) -> bigframes.series.Series

Returns the approximate top elements of expression as an array of STRUCTs.

See more: bigframes.bigquery.approx_top_count

bigframes.bigquery.array_agg

array_agg(
    obj: groupby.SeriesGroupBy | groupby.DataFrameGroupBy,
) -> series.Series | dataframe.DataFrame

Group data and create arrays from selected columns, omitting NULLs to avoid BigQuery errors (NULLs not allowed in arrays).

See more: bigframes.bigquery.array_agg

bigframes.bigquery.array_length

array_length(series: bigframes.series.Series) -> bigframes.series.Series

Compute the length of each array element in the Series.

See more: bigframes.bigquery.array_length

bigframes.bigquery.array_to_string

array_to_string(
    series: bigframes.series.Series, delimiter: str
) -> bigframes.series.Series

Converts array elements within a Series into delimited strings.

See more: bigframes.bigquery.array_to_string

bigframes.bigquery.create_vector_index

create_vector_index(
    table_id: str,
    column_name: str,
    *,
    replace: bool = False,
    index_name: Optional[str] = None,
    distance_type="cosine",
    stored_column_names: Collection[str] = (),
    index_type: str = "ivf",
    ivf_options: Optional[Mapping] = None,
    tree_ah_options: Optional[Mapping] = None,
    session: Optional[bigframes.session.Session] = None
) -> None

Creates a new vector index on a column of a table.

See more: bigframes.bigquery.create_vector_index

bigframes.bigquery.json_extract

json_extract(
    input: bigframes.series.Series, json_path: str
) -> bigframes.series.Series

Extracts a JSON value and converts it to a SQL JSON-formatted STRING or JSON value.

See more: bigframes.bigquery.json_extract

bigframes.bigquery.json_extract_array

json_extract_array(
    input: bigframes.series.Series, json_path: str = "$"
) -> bigframes.series.Series

Extracts a JSON array and converts it to a SQL array of JSON-formatted STRING or JSON values.

See more: bigframes.bigquery.json_extract_array

bigframes.bigquery.json_extract_string_array

json_extract_string_array(
    input: bigframes.series.Series,
    json_path: str = "$",
    value_dtype: typing.Optional[
        typing.Union[
            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,
            geopandas.array.GeometryDtype,
            typing.Literal[
                "boolean",
                "Float64",
                "Int64",
                "int64[pyarrow]",
                "string",
                "string[pyarrow]",
                "timestamp[us, tz=UTC][pyarrow]",
                "timestamp[us][pyarrow]",
                "date32[day][pyarrow]",
                "time64[us][pyarrow]",
                "decimal128(38, 9)[pyarrow]",
                "decimal256(76, 38)[pyarrow]",
                "binary[pyarrow]",
                "duration[us][pyarrow]",
            ],
        ]
    ] = None,
) -> bigframes.series.Series

Extracts a JSON array and converts it to a SQL array of STRING values.

See more: bigframes.bigquery.json_extract_string_array

bigframes.bigquery.json_query

json_query(
    input: bigframes.series.Series, json_path: str
) -> bigframes.series.Series

Extracts a JSON value and converts it to a SQL JSON-formatted STRING or JSON value.

See more: bigframes.bigquery.json_query

bigframes.bigquery.json_query_array

json_query_array(
    input: bigframes.series.Series, json_path: str = "$"
) -> bigframes.series.Series

Extracts a JSON array and converts it to a SQL array of JSON-formatted STRING or JSON values.

See more: bigframes.bigquery.json_query_array

bigframes.bigquery.json_set

json_set(
    input: bigframes.series.Series,
    json_path_value_pairs: typing.Sequence[typing.Tuple[str, typing.Any]],
) -> bigframes.series.Series

Produces a new JSON value within a Series by inserting or replacing values at specified paths.

See more: bigframes.bigquery.json_set

bigframes.bigquery.json_value

json_value(
    input: bigframes.series.Series, json_path: str = "$"
) -> bigframes.series.Series

Extracts a JSON scalar value and converts it to a SQL STRING value.

See more: bigframes.bigquery.json_value

bigframes.bigquery.json_value_array

json_value_array(
    input: bigframes.series.Series, json_path: str = "$"
) -> bigframes.series.Series

Extracts a JSON array of scalar values and converts it to a SQL ARRAY<STRING> value.

See more: bigframes.bigquery.json_value_array

bigframes.bigquery.parse_json

parse_json(input: bigframes.series.Series) -> bigframes.series.Series

Converts a series with a JSON-formatted STRING value to a JSON value.

See more: bigframes.bigquery.parse_json

bigframes.bigquery.sql_scalar

sql_scalar(
    sql_template: str, columns: typing.Sequence[bigframes.series.Series]
) -> bigframes.series.Series

Create a Series from a SQL template.

See more: bigframes.bigquery.sql_scalar

bigframes.bigquery.st_area

st_area(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
) -> bigframes.series.Series

Returns the area in square meters covered by the polygons in the input GEOGRAPHY.

See more: bigframes.bigquery.st_area

bigframes.bigquery.st_buffer

st_buffer(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    buffer_radius: float,
    num_seg_quarter_circle: float = 8.0,
    use_spheroid: bool = False,
) -> bigframes.series.Series

Computes a GEOGRAPHY that represents all points whose distance from the input GEOGRAPHY is less than or equal to distance meters.

See more: bigframes.bigquery.st_buffer

bigframes.bigquery.st_centroid

st_centroid(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
) -> bigframes.series.Series

Computes the geometric centroid of a GEOGRAPHY type.

See more: bigframes.bigquery.st_centroid

bigframes.bigquery.st_convexhull

st_convexhull(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
) -> bigframes.series.Series

Computes the convex hull of a GEOGRAPHY type.

See more: bigframes.bigquery.st_convexhull

bigframes.bigquery.st_difference

st_difference(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    other: typing.Union[
        bigframes.series.Series,
        bigframes.geopandas.geoseries.GeoSeries,
        shapely.geometry.base.BaseGeometry,
    ],
) -> bigframes.series.Series

Returns a GEOGRAPHY that represents the point set difference of geography_1 and geography_2.

See more: bigframes.bigquery.st_difference

bigframes.bigquery.st_distance

st_distance(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    other: typing.Union[
        bigframes.series.Series,
        bigframes.geopandas.geoseries.GeoSeries,
        shapely.geometry.base.BaseGeometry,
    ],
    *,
    use_spheroid: bool = False
) -> bigframes.series.Series

Returns the shortest distance in meters between two non-empty GEOGRAPHY objects.

See more: bigframes.bigquery.st_distance

bigframes.bigquery.st_intersection

st_intersection(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    other: typing.Union[
        bigframes.series.Series,
        bigframes.geopandas.geoseries.GeoSeries,
        shapely.geometry.base.BaseGeometry,
    ],
) -> bigframes.series.Series

Returns a GEOGRAPHY that represents the point set intersection of the two input GEOGRAPHYs.

See more: bigframes.bigquery.st_intersection

bigframes.bigquery.st_isclosed

st_isclosed(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
) -> bigframes.series.Series

Returns TRUE for a non-empty Geography, where each element in the Geography has an empty boundary.

See more: bigframes.bigquery.st_isclosed

bigframes.bigquery.st_length

st_length(
    series: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    *,
    use_spheroid: bool = False
) -> bigframes.series.Series

Returns the total length in meters of the lines in the input GEOGRAPHY.

See more: bigframes.bigquery.st_length

bigframes.bigquery.st_regionstats

st_regionstats(
    geography: typing.Union[
        bigframes.series.Series, bigframes.geopandas.geoseries.GeoSeries
    ],
    raster_id: str,
    band: typing.Optional[str] = None,
    include: typing.Optional[str] = None,
    options: typing.Optional[typing.Mapping[str, typing.Union[str, int, float]]] = None,
) -> bigframes.series.Series

Returns statistics summarizing the pixel values of the raster image referenced by raster_id that intersect with geography.

See more: bigframes.bigquery.st_regionstats

bigframes.bigquery.st_simplify

st_simplify(
    geography: bigframes.series.Series, tolerance_meters: float
) -> bigframes.series.Series

Returns a simplified version of the input geography.

See more: bigframes.bigquery.st_simplify

bigframes.bigquery.struct

struct(value: dataframe.DataFrame) -> series.Series

Takes a DataFrame and converts it into a Series of structs with each struct entry corresponding to a DataFrame row and each struct field corresponding to a DataFrame column.

See more: bigframes.bigquery.struct

bigframes.bigquery.to_json

to_json(input: bigframes.series.Series) -> bigframes.series.Series

Converts a series with a JSON value to a JSON-formatted STRING value.

See more: bigframes.bigquery.to_json

bigframes.bigquery.to_json_string

to_json_string(input: bigframes.series.Series) -> bigframes.series.Series

Converts a series to a JSON-formatted STRING value.

See more: bigframes.bigquery.to_json_string

bigframes.bigquery.unix_micros

unix_micros(input: bigframes.series.Series) -> bigframes.series.Series

Converts a timestmap series to unix epoch microseconds.

See more: bigframes.bigquery.unix_micros

bigframes.bigquery.unix_millis

unix_millis(input: bigframes.series.Series) -> bigframes.series.Series

Converts a timestmap series to unix epoch milliseconds.

See more: bigframes.bigquery.unix_millis

bigframes.bigquery.unix_seconds

unix_seconds(input: bigframes.series.Series) -> bigframes.series.Series

Converts a timestmap series to unix epoch seconds.

See more: bigframes.bigquery.unix_seconds

bigframes.bigquery.vector_search

vector_search(
    base_table: str,
    column_to_search: str,
    query: Union[dataframe.DataFrame, series.Series],
    *,
    query_column_to_search: Optional[str] = None,
    top_k: Optional[int] = None,
    distance_type: Optional[Literal["euclidean", "cosine", "dot_product"]] = None,
    fraction_lists_to_search: Optional[float] = None,
    use_brute_force: Optional[bool] = None,
    allow_large_results: Optional[bool] = None
) -> dataframe.DataFrame

Conduct vector search which searches embeddings to find semantically similar entities.

See more: bigframes.bigquery.vector_search

bigframes.bigquery._operations.ai.classify

classify(
    input: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    categories: tuple[str, ...] | list[str],
    *,
    connection_id: str | None = None
) -> bigframes.series.Series

Classifies a given input into one of the specified categories.

See more: bigframes.bigquery._operations.ai.classify

bigframes.bigquery._operations.ai.forecast

forecast(
    df: bigframes.dataframe.DataFrame | pandas.core.frame.DataFrame,
    *,
    data_col: str,
    timestamp_col: str,
    model: str = "TimesFM 2.0",
    id_cols: typing.Optional[typing.Iterable[str]] = None,
    horizon: int = 10,
    confidence_level: float = 0.95,
    context_window: int | None = None
) -> bigframes.dataframe.DataFrame

Forecast time series at future horizon.

See more: bigframes.bigquery._operations.ai.forecast

bigframes.bigquery._operations.ai.generate

generate(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None,
    endpoint: str | None = None,
    request_type: typing.Literal["dedicated", "shared", "unspecified"] = "unspecified",
    model_params: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None,
    output_schema: typing.Optional[typing.Mapping[str, str]] = None
) -> bigframes.series.Series

Returns the AI analysis based on the prompt, which can be any combination of text and unstructured data.

See more: bigframes.bigquery._operations.ai.generate

bigframes.bigquery._operations.ai.generate_bool

generate_bool(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None,
    endpoint: str | None = None,
    request_type: typing.Literal["dedicated", "shared", "unspecified"] = "unspecified",
    model_params: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None
) -> bigframes.series.Series

Returns the AI analysis based on the prompt, which can be any combination of text and unstructured data.

See more: bigframes.bigquery._operations.ai.generate_bool

bigframes.bigquery._operations.ai.generate_double

generate_double(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None,
    endpoint: str | None = None,
    request_type: typing.Literal["dedicated", "shared", "unspecified"] = "unspecified",
    model_params: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None
) -> bigframes.series.Series

Returns the AI analysis based on the prompt, which can be any combination of text and unstructured data.

See more: bigframes.bigquery._operations.ai.generate_double

bigframes.bigquery._operations.ai.generate_int

generate_int(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None,
    endpoint: str | None = None,
    request_type: typing.Literal["dedicated", "shared", "unspecified"] = "unspecified",
    model_params: typing.Optional[typing.Mapping[typing.Any, typing.Any]] = None
) -> bigframes.series.Series

Returns the AI analysis based on the prompt, which can be any combination of text and unstructured data.

See more: bigframes.bigquery._operations.ai.generate_int

bigframes.bigquery._operations.ai.if_

if_(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None
) -> bigframes.series.Series

Evaluates the prompt to True or False.

See more: bigframes.bigquery.operations.ai.if

bigframes.bigquery._operations.ai.score

score(
    prompt: typing.Union[
        str,
        bigframes.series.Series,
        pandas.core.series.Series,
        typing.List[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series]
        ],
        typing.Tuple[
            typing.Union[str, bigframes.series.Series, pandas.core.series.Series], ...
        ],
    ],
    *,
    connection_id: str | None = None
) -> bigframes.series.Series

Computes a score based on rubrics described in natural language.

See more: bigframes.bigquery._operations.ai.score

bigframes.exceptions.format_message

format_message(message: str, fill: bool = True)

Formats a warning message with ANSI color codes for the warning color.

See more: bigframes.exceptions.format_message

bigframes.ml.metrics.accuracy_score

accuracy_score(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    normalize=True
) -> float

Accuracy classification score.

See more: bigframes.ml.metrics.accuracy_score

bigframes.ml.metrics.auc

auc(
    x: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> float

Compute Area Under the Curve (AUC) using the trapezoidal rule.

See more: bigframes.ml.metrics.auc

bigframes.ml.metrics.confusion_matrix

confusion_matrix(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> pandas.core.frame.DataFrame

Compute confusion matrix to evaluate the accuracy of a classification.

See more: bigframes.ml.metrics.confusion_matrix

bigframes.ml.metrics.f1_score

f1_score(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    average: typing.Optional[str] = "binary"
) -> pandas.core.series.Series

Compute the F1 score, also known as balanced F-score or F-measure.

See more: bigframes.ml.metrics.f1_score

bigframes.ml.metrics.mean_absolute_error

mean_absolute_error(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> float

Mean absolute error regression loss.

See more: bigframes.ml.metrics.mean_absolute_error

bigframes.ml.metrics.mean_squared_error

mean_squared_error(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> float

Mean squared error regression loss.

See more: bigframes.ml.metrics.mean_squared_error

bigframes.ml.metrics.precision_score

precision_score(
    y_true: bigframes.dataframe.DataFrame | bigframes.series.Series,
    y_pred: bigframes.dataframe.DataFrame | bigframes.series.Series,
    *,
    pos_label: int | float | bool | str = 1,
    average: typing.Optional[typing.Literal["binary"]] = "binary"
) -> pandas.core.series.Series | float

Compute the precision.

See more: bigframes.ml.metrics.precision_score

bigframes.ml.metrics.r2_score

r2_score(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    force_finite=True
) -> float

:math:R^2 (coefficient of determination) regression score function.

See more: bigframes.ml.metrics.r2_score

bigframes.ml.metrics.recall_score

recall_score(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_pred: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    average: typing.Optional[str] = "binary"
) -> pandas.core.series.Series

Compute the recall.

See more: bigframes.ml.metrics.recall_score

bigframes.ml.metrics.roc_auc_score

roc_auc_score(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_score: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> float

Compute Area Under the Receiver Operating Characteristic Curve (ROC AUC) from prediction scores.

See more: bigframes.ml.metrics.roc_auc_score

bigframes.ml.metrics.roc_curve

roc_curve(
    y_true: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y_score: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    drop_intermediate: bool = True
) -> typing.Tuple[
    bigframes.series.Series, bigframes.series.Series, bigframes.series.Series
]

Compute Receiver operating characteristic (ROC).

See more: bigframes.ml.metrics.roc_curve

bigframes.ml.metrics.pairwise.paired_cosine_distances

paired_cosine_distances(
    X: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    Y: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> bigframes.dataframe.DataFrame

Compute the paired cosine distances between X and Y.

See more: bigframes.ml.metrics.pairwise.paired_cosine_distances

bigframes.ml.metrics.pairwise.paired_euclidean_distances

paired_euclidean_distances(
    X: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    Y: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> bigframes.dataframe.DataFrame

Compute the paired euclidean distances between X and Y.

See more: bigframes.ml.metrics.pairwise.paired_euclidean_distances

bigframes.ml.metrics.pairwise.paired_manhattan_distance

paired_manhattan_distance(
    X: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    Y: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
) -> bigframes.dataframe.DataFrame

Compute the L1 distances between the vectors in X and Y.

See more: bigframes.ml.metrics.pairwise.paired_manhattan_distance

bigframes.ml.model_selection.cross_validate

cross_validate(
    estimator,
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    *,
    cv: typing.Optional[typing.Union[int, bigframes.ml.model_selection.KFold]] = None
) -> dict[str, list]

Evaluate metric(s) by cross-validation and also record fit/score times.

See more: bigframes.ml.model_selection.cross_validate

bigframes.ml.model_selection.train_test_split

train_test_split(
    *arrays: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    test_size: typing.Optional[float] = None,
    train_size: typing.Optional[float] = None,
    random_state: typing.Optional[int] = None,
    stratify: typing.Optional[bigframes.series.Series] = None,
    shuffle: bool = True
) -> typing.List[typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]]

Splits dataframes or series into random train and test subsets.

See more: bigframes.ml.model_selection.train_test_split

bigframes.pandas.clean_up_by_session_id

clean_up_by_session_id(
    session_id: str,
    location: typing.Optional[str] = None,
    project: typing.Optional[str] = None,
) -> None

Searches through BigQuery tables and routines and deletes the ones created during the session with the given session id.

See more: bigframes.pandas.clean_up_by_session_id

bigframes.pandas.close_session

close_session()

Start a fresh session the next time a function requires a session.

See more: bigframes.pandas.close_session

bigframes.pandas.concat

concat(
    objs: typing.Iterable[
        typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]
    ],
    *,
    axis: typing.Union[str, int] = 0,
    join: typing.Literal["inner", "outer"] = "outer",
    ignore_index: bool = False
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Concatenate BigQuery DataFrames objects along a particular axis.

See more: bigframes.pandas.concat

bigframes.pandas.cut

cut(
    x,
    bins: typing.Union[
        int, pandas.core.indexes.interval.IntervalIndex, typing.Iterable
    ],
    *,
    right: typing.Optional[bool] = True,
    labels: typing.Optional[typing.Union[typing.Iterable[str], bool]] = None,
    session: typing.Optional[bigframes.session.Session] = None
) -> bigframes.series.Series

Bin values into discrete intervals.

See more: bigframes.pandas.cut

bigframes.pandas.deploy_remote_function

deploy_remote_function(func, **kwargs)

Orchestrates the creation of a BigQuery remote function that deploys immediately.

See more: bigframes.pandas.deploy_remote_function

bigframes.pandas.deploy_udf

deploy_udf(func, **kwargs)

Orchestrates the creation of a BigQuery UDF that deploys immediately.

See more: bigframes.pandas.deploy_udf

bigframes.pandas.from_glob_path

from_glob_path(
    path: str,
    *,
    connection: typing.Optional[str] = None,
    name: typing.Optional[str] = None
) -> bigframes.dataframe.DataFrame

Create a BigFrames DataFrame that contains a BigFrames Blob column from a global wildcard path.

See more: bigframes.pandas.from_glob_path

bigframes.pandas.get_default_session_id

get_default_session_id() -> str

Gets the session id that is used whenever a custom session has not been provided.

See more: bigframes.pandas.get_default_session_id

bigframes.pandas.get_dummies

get_dummies(
    data: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    prefix: typing.Optional[typing.Union[typing.List, dict, str]] = None,
    prefix_sep: typing.Optional[typing.Union[typing.List, dict, str]] = "_",
    dummy_na: bool = False,
    columns: typing.Optional[typing.List] = None,
    drop_first: bool = False,
    dtype: typing.Any = None,
) -> bigframes.dataframe.DataFrame

Convert categorical variable into dummy/indicator variables.

See more: bigframes.pandas.get_dummies

bigframes.pandas.get_global_session

get_global_session()

Gets the global session.

See more: bigframes.pandas.get_global_session

bigframes.pandas.merge

merge(
    left: bigframes.dataframe.DataFrame,
    right: bigframes.dataframe.DataFrame,
    how: typing.Literal["inner", "left", "outer", "right", "cross"] = "inner",
    on: typing.Optional[
        typing.Union[typing.Sequence[typing.Hashable], typing.Hashable]
    ] = None,
    *,
    left_on: typing.Optional[
        typing.Union[typing.Sequence[typing.Hashable], typing.Hashable]
    ] = None,
    right_on: typing.Optional[
        typing.Union[typing.Sequence[typing.Hashable], typing.Hashable]
    ] = None,
    left_index: bool = False,
    right_index: bool = False,
    sort: bool = False,
    suffixes: tuple[str, str] = ("_x", "_y")
) -> bigframes.dataframe.DataFrame

Merge DataFrame objects with a database-style join.

See more: bigframes.pandas.merge

bigframes.pandas.qcut

qcut(
    x: bigframes.series.Series,
    q: typing.Union[int, typing.Sequence[float]],
    *,
    labels: typing.Optional[bool] = None,
    duplicates: typing.Literal["drop", "error"] = "error"
) -> bigframes.series.Series

Quantile-based discretization function.

See more: bigframes.pandas.qcut

bigframes.pandas.read_arrow

read_arrow(pa_table: pyarrow.lib.Table) -> bigframes.dataframe.DataFrame

Load a PyArrow Table to a BigQuery DataFrames DataFrame.

See more: bigframes.pandas.read_arrow

bigframes.pandas.read_csv

read_csv(
    filepath_or_buffer: typing.Union[str, typing.IO[bytes]],
    *,
    sep: typing.Optional[str] = ",",
    header: typing.Optional[int] = 0,
    names: typing.Optional[
        typing.Union[
            typing.MutableSequence[typing.Any],
            numpy.ndarray[typing.Any, typing.Any],
            typing.Tuple[typing.Any, ...],
            range,
        ]
    ] = None,
    index_col: typing.Optional[
        typing.Union[
            int,
            str,
            typing.Sequence[typing.Union[str, int]],
            bigframes.enums.DefaultIndexKind,
            typing.Literal[False],
        ]
    ] = None,
    usecols: typing.Optional[
        typing.Union[
            typing.MutableSequence[str],
            typing.Tuple[str, ...],
            typing.Sequence[int],
            pandas.core.series.Series,
            pandas.core.indexes.base.Index,
            numpy.ndarray[typing.Any, typing.Any],
            typing.Callable[[typing.Any], bool],
        ]
    ] = None,
    dtype: typing.Optional[typing.Dict] = None,
    engine: typing.Optional[
        typing.Literal["c", "python", "pyarrow", "python-fwf", "bigquery"]
    ] = None,
    encoding: typing.Optional[str] = None,
    write_engine: typing.Literal[
        "default",
        "bigquery_inline",
        "bigquery_load",
        "bigquery_streaming",
        "bigquery_write",
        "_deferred",
    ] = "default",
    **kwargs
) -> bigframes.dataframe.DataFrame

Loads data from a comma-separated values (csv) file into a DataFrame.

See more: bigframes.pandas.read_csv

bigframes.pandas.read_gbq

read_gbq(
    query_or_table: str,
    *,
    index_col: typing.Union[
        typing.Iterable[str], str, bigframes.enums.DefaultIndexKind
    ] = (),
    columns: typing.Iterable[str] = (),
    configuration: typing.Optional[typing.Dict] = None,
    max_results: typing.Optional[int] = None,
    filters: typing.Union[
        typing.Iterable[
            typing.Tuple[
                str,
                typing.Literal[
                    "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                ],
                typing.Any,
            ]
        ],
        typing.Iterable[
            typing.Iterable[
                typing.Tuple[
                    str,
                    typing.Literal[
                        "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                    ],
                    typing.Any,
                ]
            ]
        ],
    ] = (),
    use_cache: typing.Optional[bool] = None,
    col_order: typing.Iterable[str] = (),
    dry_run: bool = False,
    allow_large_results: typing.Optional[bool] = None
) -> bigframes.dataframe.DataFrame | pandas.core.series.Series

Loads a DataFrame from BigQuery.

See more: bigframes.pandas.read_gbq

bigframes.pandas.read_gbq_function

read_gbq_function(function_name: str, is_row_processor: bool = False)

Loads a BigQuery function from BigQuery.

See more: bigframes.pandas.read_gbq_function

bigframes.pandas.read_gbq_model

read_gbq_model(model_name: str)

Loads a BigQuery ML model from BigQuery.

See more: bigframes.pandas.read_gbq_model

bigframes.pandas.read_gbq_object_table

read_gbq_object_table(
    object_table: str, *, name: typing.Optional[str] = None
) -> bigframes.dataframe.DataFrame

Read an existing object table to create a BigFrames Blob DataFrame.

See more: bigframes.pandas.read_gbq_object_table

bigframes.pandas.read_gbq_query

read_gbq_query(
    query: str,
    *,
    index_col: typing.Union[
        typing.Iterable[str], str, bigframes.enums.DefaultIndexKind
    ] = (),
    columns: typing.Iterable[str] = (),
    configuration: typing.Optional[typing.Dict] = None,
    max_results: typing.Optional[int] = None,
    use_cache: typing.Optional[bool] = None,
    col_order: typing.Iterable[str] = (),
    filters: typing.Union[
        typing.Iterable[
            typing.Tuple[
                str,
                typing.Literal[
                    "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                ],
                typing.Any,
            ]
        ],
        typing.Iterable[
            typing.Iterable[
                typing.Tuple[
                    str,
                    typing.Literal[
                        "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                    ],
                    typing.Any,
                ]
            ]
        ],
    ] = (),
    dry_run: bool = False,
    allow_large_results: typing.Optional[bool] = None
) -> bigframes.dataframe.DataFrame | pandas.core.series.Series

Turn a SQL query into a DataFrame.

See more: bigframes.pandas.read_gbq_query

bigframes.pandas.read_gbq_table

read_gbq_table(
    query: str,
    *,
    index_col: typing.Union[
        typing.Iterable[str], str, bigframes.enums.DefaultIndexKind
    ] = (),
    columns: typing.Iterable[str] = (),
    max_results: typing.Optional[int] = None,
    filters: typing.Union[
        typing.Iterable[
            typing.Tuple[
                str,
                typing.Literal[
                    "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                ],
                typing.Any,
            ]
        ],
        typing.Iterable[
            typing.Iterable[
                typing.Tuple[
                    str,
                    typing.Literal[
                        "in", "not in", "<",><=", "="=" ,"="" "!=", ">=", ">", "LIKE"
                    ],
                    typing.Any,
                ]
            ]
        ],
    ] = (),
    use_cache: bool = True,
    col_order: typing.Iterable[str] = (),
    dry_run: bool = False
) -> bigframes.dataframe.DataFrame | pandas.core.series.Series

Turn a BigQuery table into a DataFrame.

See more: bigframes.pandas.read_gbq_table

bigframes.pandas.read_json

read_json(
    path_or_buf: typing.Union[str, typing.IO[bytes]],
    *,
    orient: typing.Literal[
        "split", "records", "index", "columns", "values", "table"
    ] = "columns",
    dtype: typing.Optional[typing.Dict] = None,
    encoding: typing.Optional[str] = None,
    lines: bool = False,
    engine: typing.Literal["ujson", "pyarrow", "bigquery"] = "ujson",
    write_engine: typing.Literal[
        "default",
        "bigquery_inline",
        "bigquery_load",
        "bigquery_streaming",
        "bigquery_write",
        "_deferred",
    ] = "default",
    **kwargs
) -> bigframes.dataframe.DataFrame

Convert a JSON string to DataFrame object.

See more: bigframes.pandas.read_json

bigframes.pandas.read_pandas

read_pandas(
    pandas_dataframe: typing.Union[
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
        pandas.core.indexes.base.Index,
    ],
    *,
    write_engine: typing.Literal[
        "default",
        "bigquery_inline",
        "bigquery_load",
        "bigquery_streaming",
        "bigquery_write",
        "_deferred",
    ] = "default"
)

Loads DataFrame from a pandas DataFrame.

See more: bigframes.pandas.read_pandas

bigframes.pandas.read_parquet

read_parquet(
    path: typing.Union[str, typing.IO[bytes]],
    *,
    engine: str = "auto",
    write_engine: typing.Literal[
        "default",
        "bigquery_inline",
        "bigquery_load",
        "bigquery_streaming",
        "bigquery_write",
        "_deferred",
    ] = "default"
) -> bigframes.dataframe.DataFrame

Load a Parquet object from the file path (local or Cloud Storage), returning a DataFrame.

See more: bigframes.pandas.read_parquet

bigframes.pandas.read_pickle

read_pickle(
    filepath_or_buffer: FilePath | ReadPickleBuffer,
    compression: CompressionOptions = "infer",
    storage_options: StorageOptions = None,
    *,
    write_engine: constants.WriteEngineType = "default"
)

Load pickled BigFrames object (or any object) from file.

See more: bigframes.pandas.read_pickle

bigframes.pandas.remote_function

remote_function(
    input_types: typing.Union[None, type, typing.Sequence[type]] = None,
    output_type: typing.Optional[type] = None,
    dataset: typing.Optional[str] = None,
    *,
    bigquery_connection: typing.Optional[str] = None,
    reuse: bool = True,
    name: typing.Optional[str] = None,
    packages: typing.Optional[typing.Sequence[str]] = None,
    cloud_function_service_account: str,
    cloud_function_kms_key_name: typing.Optional[str] = None,
    cloud_function_docker_repository: typing.Optional[str] = None,
    max_batching_rows: typing.Optional[int] = 1000,
    cloud_function_timeout: typing.Optional[int] = 600,
    cloud_function_max_instances: typing.Optional[int] = None,
    cloud_function_vpc_connector: typing.Optional[str] = None,
    cloud_function_vpc_connector_egress_settings: typing.Optional[
        typing.Literal["all", "private-ranges-only", "unspecified"]
    ] = None,
    cloud_function_memory_mib: typing.Optional[int] = 1024,
    cloud_function_ingress_settings: typing.Literal[
        "all", "internal-only", "internal-and-gclb"
    ] = "internal-only",
    cloud_build_service_account: typing.Optional[str] = None
)

Decorator to turn a user defined function into a BigQuery remote function.

See more: bigframes.pandas.remote_function

bigframes.pandas.reset_session

reset_session()

Start a fresh session the next time a function requires a session.

See more: bigframes.pandas.reset_session

bigframes.pandas.to_datetime

This function converts a scalar, array-like or Series to a datetime object.

See more: bigframes.pandas.to_datetime

bigframes.pandas.to_timedelta

to_timedelta(
    arg,
    unit: typing.Optional[
        typing.Literal[
            "W",
            "w",
            "D",
            "d",
            "days",
            "day",
            "hours",
            "hour",
            "hr",
            "h",
            "m",
            "minute",
            "min",
            "minutes",
            "s",
            "seconds",
            "sec",
            "second",
            "ms",
            "milliseconds",
            "millisecond",
            "milli",
            "millis",
            "us",
            "microseconds",
            "microsecond",
            "µs",
            "micro",
            "micros",
        ]
    ] = None,
    *,
    session: typing.Optional[bigframes.session.Session] = None
)

Converts a scalar or Series to a timedelta object.

See more: bigframes.pandas.to_timedelta

bigframes.pandas.udf

udf(
    *,
    input_types: typing.Union[None, type, typing.Sequence[type]] = None,
    output_type: typing.Optional[type] = None,
    dataset: str,
    bigquery_connection: typing.Optional[str] = None,
    name: str,
    packages: typing.Optional[typing.Sequence[str]] = None,
    max_batching_rows: typing.Optional[int] = None,
    container_cpu: typing.Optional[float] = None,
    container_memory: typing.Optional[str] = None
)

Decorator to turn a Python user defined function (udf) into a BigQuery managed user-defined function.

See more: bigframes.pandas.udf

bigframes.streaming.read_gbq_table

read_gbq_table(table: str) -> bigframes.streaming.dataframe.StreamingDataFrame

Turn a BigQuery table into a StreamingDataFrame.

See more: bigframes.streaming.read_gbq_table

bigframes._config.Options.reset

reset() -> bigframes._config.Options

Reset the option settings to defaults.

See more: bigframes._config.Options.reset

bigframes._config.compute_options.ComputeOptions.assign_extra_query_labels

assign_extra_query_labels(**kwargs: typing.Any) -> None

Assigns additional custom labels for query configuration.

See more: bigframes._config.compute_options.ComputeOptions.assign_extra_query_labels

bigframes._config.sampling_options.SamplingOptions.with_disabled

with_disabled() -> bigframes._config.sampling_options.SamplingOptions

Configures whether to disable downsampling .

See more: bigframes._config.sampling_options.SamplingOptions.with_disabled

bigframes._config.sampling_options.SamplingOptions.with_max_download_size

with_max_download_size(
    max_rows: typing.Optional[int],
) -> bigframes._config.sampling_options.SamplingOptions

Configures the maximum download size for data sampling in MB .

See more: bigframes._config.sampling_options.SamplingOptions.with_max_download_size

bigframes._config.sampling_options.SamplingOptions.with_method

with_method(
    method: typing.Literal["head", "uniform"],
) -> bigframes._config.sampling_options.SamplingOptions

Configures the downsampling algorithms to be chosen from .

See more: bigframes._config.sampling_options.SamplingOptions.with_method

bigframes._config.sampling_options.SamplingOptions.with_random_state

with_random_state(
    state: typing.Optional[int],
) -> bigframes._config.sampling_options.SamplingOptions

Configures the seed for the uniform downsampling algorithm .

See more: bigframes._config.sampling_options.SamplingOptions.with_random_state

bigframes.core.groupby.DataFrameGroupBy.agg

agg(
    func=None, **kwargs
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Aggregate using one or more operations.

See more: bigframes.core.groupby.DataFrameGroupBy.agg

bigframes.core.groupby.DataFrameGroupBy.aggregate

aggregate(
    func=None, **kwargs
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Aggregate using one or more operations.

See more: bigframes.core.groupby.DataFrameGroupBy.aggregate

bigframes.core.groupby.DataFrameGroupBy.all

all() -> bigframes.dataframe.DataFrame

Return True if all values in the group are true, else False.

See more: bigframes.core.groupby.DataFrameGroupBy.all

bigframes.core.groupby.DataFrameGroupBy.any

any() -> bigframes.dataframe.DataFrame

Return True if any value in the group is true, else False.

See more: bigframes.core.groupby.DataFrameGroupBy.any

bigframes.core.groupby.DataFrameGroupBy.corr

corr(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute pairwise correlation of columns, excluding NA/null values.

See more: bigframes.core.groupby.DataFrameGroupBy.corr

bigframes.core.groupby.DataFrameGroupBy.count

count() -> bigframes.dataframe.DataFrame

Compute count of group, excluding missing values.

See more: bigframes.core.groupby.DataFrameGroupBy.count

bigframes.core.groupby.DataFrameGroupBy.cov

cov(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute pairwise covariance of columns, excluding NA/null values.

See more: bigframes.core.groupby.DataFrameGroupBy.cov

bigframes.core.groupby.DataFrameGroupBy.cumcount

cumcount(ascending: bool = True) -> bigframes.series.Series

Number each item in each group from 0 to the length of that group - 1.

See more: bigframes.core.groupby.DataFrameGroupBy.cumcount

bigframes.core.groupby.DataFrameGroupBy.cummax

cummax(
    *args, numeric_only: bool = False, **kwargs
) -> bigframes.dataframe.DataFrame

Cumulative max for each group.

See more: bigframes.core.groupby.DataFrameGroupBy.cummax

bigframes.core.groupby.DataFrameGroupBy.cummin

cummin(
    *args, numeric_only: bool = False, **kwargs
) -> bigframes.dataframe.DataFrame

Cumulative min for each group.

See more: bigframes.core.groupby.DataFrameGroupBy.cummin

bigframes.core.groupby.DataFrameGroupBy.cumprod

cumprod(*args, **kwargs) -> bigframes.dataframe.DataFrame

Cumulative product for each group.

See more: bigframes.core.groupby.DataFrameGroupBy.cumprod

bigframes.core.groupby.DataFrameGroupBy.cumsum

cumsum(
    *args, numeric_only: bool = False, **kwargs
) -> bigframes.dataframe.DataFrame

Cumulative sum for each group.

See more: bigframes.core.groupby.DataFrameGroupBy.cumsum

bigframes.core.groupby.DataFrameGroupBy.describe

describe(include: typing.Union[None, typing.Literal["all"]] = None)

Generate descriptive statistics.

See more: bigframes.core.groupby.DataFrameGroupBy.describe

bigframes.core.groupby.DataFrameGroupBy.diff

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

First discrete difference of element.

See more: bigframes.core.groupby.DataFrameGroupBy.diff

bigframes.core.groupby.DataFrameGroupBy.expanding

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

Provides expanding functionality.

See more: bigframes.core.groupby.DataFrameGroupBy.expanding

bigframes.core.groupby.DataFrameGroupBy.first

first(
    numeric_only: bool = False, min_count: int = -1
) -> bigframes.dataframe.DataFrame

Compute the first entry of each column within each group.

See more: bigframes.core.groupby.DataFrameGroupBy.first

bigframes.core.groupby.DataFrameGroupBy.head

head(n: int = 5) -> bigframes.dataframe.DataFrame

Return last first n rows of each group.

See more: bigframes.core.groupby.DataFrameGroupBy.head

bigframes.core.groupby.DataFrameGroupBy.kurt

kurt(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Return unbiased kurtosis over requested axis.

See more: bigframes.core.groupby.DataFrameGroupBy.kurt

bigframes.core.groupby.DataFrameGroupBy.kurtosis

kurtosis(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Return unbiased kurtosis over requested axis.

See more: bigframes.core.groupby.DataFrameGroupBy.kurtosis

bigframes.core.groupby.DataFrameGroupBy.last

last(
    numeric_only: bool = False, min_count: int = -1
) -> bigframes.dataframe.DataFrame

Compute the last entry of each column within each group.

See more: bigframes.core.groupby.DataFrameGroupBy.last

bigframes.core.groupby.DataFrameGroupBy.max

max(numeric_only: bool = False, *args) -> bigframes.dataframe.DataFrame

Compute max of group values.

See more: bigframes.core.groupby.DataFrameGroupBy.max

bigframes.core.groupby.DataFrameGroupBy.mean

mean(numeric_only: bool = False, *args) -> bigframes.dataframe.DataFrame

Compute mean of groups, excluding missing values.

See more: bigframes.core.groupby.DataFrameGroupBy.mean

bigframes.core.groupby.DataFrameGroupBy.median

median(
    numeric_only: bool = False, *, exact: bool = True
) -> bigframes.dataframe.DataFrame

Compute median of groups, excluding missing values.

See more: bigframes.core.groupby.DataFrameGroupBy.median

bigframes.core.groupby.DataFrameGroupBy.min

min(numeric_only: bool = False, *args) -> bigframes.dataframe.DataFrame

Compute min of group values.

See more: bigframes.core.groupby.DataFrameGroupBy.min

bigframes.core.groupby.DataFrameGroupBy.nunique

nunique() -> bigframes.dataframe.DataFrame

Return DataFrame with counts of unique elements in each position.

See more: bigframes.core.groupby.DataFrameGroupBy.nunique

bigframes.core.groupby.DataFrameGroupBy.prod

prod(numeric_only: bool = False, min_count: int = 0)

Compute prod of group values.

See more: bigframes.core.groupby.DataFrameGroupBy.prod

bigframes.core.groupby.DataFrameGroupBy.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5, *, numeric_only: bool = False
) -> bigframes.dataframe.DataFrame

Return group values at the given quantile, a la numpy.percentile.

See more: bigframes.core.groupby.DataFrameGroupBy.quantile

bigframes.core.groupby.DataFrameGroupBy.rank

rank(
    method="average", ascending: bool = True, na_option: str = "keep", pct: bool = False
) -> bigframes.dataframe.DataFrame

Provide the rank of values within each group.

See more: bigframes.core.groupby.DataFrameGroupBy.rank

bigframes.core.groupby.DataFrameGroupBy.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods=None,
    on: str | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Returns a rolling grouper, providing rolling functionality per group.

See more: bigframes.core.groupby.DataFrameGroupBy.rolling

bigframes.core.groupby.DataFrameGroupBy.shift

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

Shift each group by periods observations.

See more: bigframes.core.groupby.DataFrameGroupBy.shift

bigframes.core.groupby.DataFrameGroupBy.size

size() -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Compute group sizes.

See more: bigframes.core.groupby.DataFrameGroupBy.size

bigframes.core.groupby.DataFrameGroupBy.skew

skew(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Return unbiased skew within groups.

See more: bigframes.core.groupby.DataFrameGroupBy.skew

bigframes.core.groupby.DataFrameGroupBy.std

std(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute standard deviation of groups, excluding missing values.

See more: bigframes.core.groupby.DataFrameGroupBy.std

bigframes.core.groupby.DataFrameGroupBy.sum

sum(numeric_only: bool = False, *args) -> bigframes.dataframe.DataFrame

Compute sum of group values.

See more: bigframes.core.groupby.DataFrameGroupBy.sum

bigframes.core.groupby.DataFrameGroupBy.value_counts

value_counts(
    subset: typing.Optional[typing.Sequence[typing.Hashable]] = None,
    normalize: bool = False,
    sort: bool = True,
    ascending: bool = False,
    dropna: bool = True,
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Return a Series or DataFrame containing counts of unique rows.

See more: bigframes.core.groupby.DataFrameGroupBy.value_counts

bigframes.core.groupby.DataFrameGroupBy.var

var(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute variance of groups, excluding missing values.

See more: bigframes.core.groupby.DataFrameGroupBy.var

bigframes.core.groupby.SeriesGroupBy.agg

agg(
    func=None,
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Aggregate using one or more operations.

See more: bigframes.core.groupby.SeriesGroupBy.agg

bigframes.core.groupby.SeriesGroupBy.aggregate

aggregate(
    func=None,
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Aggregate using one or more operations.

See more: bigframes.core.groupby.SeriesGroupBy.aggregate

bigframes.core.groupby.SeriesGroupBy.all

all() -> bigframes.series.Series

Return True if all values in the group are true, else False.

See more: bigframes.core.groupby.SeriesGroupBy.all

bigframes.core.groupby.SeriesGroupBy.any

any() -> bigframes.series.Series

Return True if any value in the group is true, else False.

See more: bigframes.core.groupby.SeriesGroupBy.any

bigframes.core.groupby.SeriesGroupBy.count

count() -> bigframes.series.Series

Compute count of group, excluding missing values.

See more: bigframes.core.groupby.SeriesGroupBy.count

bigframes.core.groupby.SeriesGroupBy.cumcount

cumcount(*args, **kwargs) -> bigframes.series.Series

Number each item in each group from 0 to the length of that group - 1.

See more: bigframes.core.groupby.SeriesGroupBy.cumcount

bigframes.core.groupby.SeriesGroupBy.cummax

cummax(*args, **kwargs) -> bigframes.series.Series

Cumulative max for each group.

See more: bigframes.core.groupby.SeriesGroupBy.cummax

bigframes.core.groupby.SeriesGroupBy.cummin

cummin(*args, **kwargs) -> bigframes.series.Series

Cumulative min for each group.

See more: bigframes.core.groupby.SeriesGroupBy.cummin

bigframes.core.groupby.SeriesGroupBy.cumprod

cumprod(*args, **kwargs) -> bigframes.series.Series

Cumulative product for each group.

See more: bigframes.core.groupby.SeriesGroupBy.cumprod

bigframes.core.groupby.SeriesGroupBy.cumsum

cumsum(*args, **kwargs) -> bigframes.series.Series

Cumulative sum for each group.

See more: bigframes.core.groupby.SeriesGroupBy.cumsum

bigframes.core.groupby.SeriesGroupBy.describe

describe(include: typing.Union[None, typing.Literal["all"]] = None)

Generate descriptive statistics.

See more: bigframes.core.groupby.SeriesGroupBy.describe

bigframes.core.groupby.SeriesGroupBy.diff

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

First discrete difference of element.

See more: bigframes.core.groupby.SeriesGroupBy.diff

bigframes.core.groupby.SeriesGroupBy.expanding

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

Provides expanding functionality.

See more: bigframes.core.groupby.SeriesGroupBy.expanding

bigframes.core.groupby.SeriesGroupBy.first

first(numeric_only: bool = False, min_count: int = -1) -> bigframes.series.Series

Compute the first entry of each column within each group.

See more: bigframes.core.groupby.SeriesGroupBy.first

bigframes.core.groupby.SeriesGroupBy.head

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

Return last first n rows of each group.

See more: bigframes.core.groupby.SeriesGroupBy.head

bigframes.core.groupby.SeriesGroupBy.kurt

kurt(*args, **kwargs) -> bigframes.series.Series

Return unbiased kurtosis over requested axis.

See more: bigframes.core.groupby.SeriesGroupBy.kurt

bigframes.core.groupby.SeriesGroupBy.kurtosis

kurtosis(*args, **kwargs) -> bigframes.series.Series

Return unbiased kurtosis over requested axis.

See more: bigframes.core.groupby.SeriesGroupBy.kurtosis

bigframes.core.groupby.SeriesGroupBy.last

last(numeric_only: bool = False, min_count: int = -1) -> bigframes.series.Series

Compute the last entry of each column within each group.

See more: bigframes.core.groupby.SeriesGroupBy.last

bigframes.core.groupby.SeriesGroupBy.max

max(*args) -> bigframes.series.Series

Compute max of group values.

See more: bigframes.core.groupby.SeriesGroupBy.max

bigframes.core.groupby.SeriesGroupBy.mean

mean(*args) -> bigframes.series.Series

Compute mean of groups, excluding missing values.

See more: bigframes.core.groupby.SeriesGroupBy.mean

bigframes.core.groupby.SeriesGroupBy.median

median(*args, exact: bool = True, **kwargs) -> bigframes.series.Series

Compute median of groups, excluding missing values.

See more: bigframes.core.groupby.SeriesGroupBy.median

bigframes.core.groupby.SeriesGroupBy.min

min(*args) -> bigframes.series.Series

Compute min of group values.

See more: bigframes.core.groupby.SeriesGroupBy.min

bigframes.core.groupby.SeriesGroupBy.nunique

nunique() -> bigframes.series.Series

Return number of unique elements in the group.

See more: bigframes.core.groupby.SeriesGroupBy.nunique

bigframes.core.groupby.SeriesGroupBy.prod

prod(*args) -> bigframes.series.Series

Compute prod of group values.

See more: bigframes.core.groupby.SeriesGroupBy.prod

bigframes.core.groupby.SeriesGroupBy.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5, *, numeric_only: bool = False
) -> bigframes.series.Series

Return group values at the given quantile, a la numpy.percentile.

See more: bigframes.core.groupby.SeriesGroupBy.quantile

bigframes.core.groupby.SeriesGroupBy.rank

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

Provide the rank of values within each group.

See more: bigframes.core.groupby.SeriesGroupBy.rank

bigframes.core.groupby.SeriesGroupBy.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods=None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Returns a rolling grouper, providing rolling functionality per group.

See more: bigframes.core.groupby.SeriesGroupBy.rolling

bigframes.core.groupby.SeriesGroupBy.shift

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

Shift index by desired number of periods.

See more: bigframes.core.groupby.SeriesGroupBy.shift

bigframes.core.groupby.SeriesGroupBy.size

size() -> bigframes.series.Series

Compute group sizes.

See more: bigframes.core.groupby.SeriesGroupBy.size

bigframes.core.groupby.SeriesGroupBy.skew

skew(*args, **kwargs) -> bigframes.series.Series

Return unbiased skew within groups.

See more: bigframes.core.groupby.SeriesGroupBy.skew

bigframes.core.groupby.SeriesGroupBy.std

std(*args, **kwargs) -> bigframes.series.Series

Compute standard deviation of groups, excluding missing values.

See more: bigframes.core.groupby.SeriesGroupBy.std

bigframes.core.groupby.SeriesGroupBy.sum

sum(*args) -> bigframes.series.Series

Compute sum of group values.

See more: bigframes.core.groupby.SeriesGroupBy.sum

bigframes.core.groupby.SeriesGroupBy.value_counts

value_counts(
    normalize: bool = False,
    sort: bool = True,
    ascending: bool = False,
    dropna: bool = True,
) -> typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]

Return a Series or DataFrame containing counts of unique rows.

See more: bigframes.core.groupby.SeriesGroupBy.value_counts

bigframes.core.groupby.SeriesGroupBy.var

var(*args, **kwargs) -> bigframes.series.Series

Compute variance of groups, excluding missing values.

See more: bigframes.core.groupby.SeriesGroupBy.var

bigframes.core.indexers.ILocDataFrameIndexer.getitem

__getitem__(
    key,
) -> typing.Union[bigframes.dataframe.DataFrame, pandas.core.series.Series]

Index dataframe using integer offsets.

See more: bigframes.core.indexers.ILocDataFrameIndexer.getitem

bigframes.core.indexers.IlocSeriesIndexer.getitem

__getitem__(key) -> typing.Union[typing.Any, bigframes.series.Series]

Index series using integer offsets.

See more: bigframes.core.indexers.IlocSeriesIndexer.getitem

bigframes.core.indexes.base.Index.setitem

__setitem__(key, value) -> None

Index objects are immutable.

See more: bigframes.core.indexes.base.Index.setitem

bigframes.core.indexes.base.Index.all

all() -> bool

Return whether all elements are Truthy.

See more: bigframes.core.indexes.base.Index.all

bigframes.core.indexes.base.Index.any

any() -> bool

Return whether any element is Truthy.

See more: bigframes.core.indexes.base.Index.any

bigframes.core.indexes.base.Index.argmax

argmax() -> int

Return int position of the largest value in the Series.

See more: bigframes.core.indexes.base.Index.argmax

bigframes.core.indexes.base.Index.argmin

argmin() -> int

Return int position of the smallest value in the series.

See more: bigframes.core.indexes.base.Index.argmin

bigframes.core.indexes.base.Index.astype

astype(
    dtype, *, errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.core.indexes.base.Index

Create an Index with values cast to dtypes.

See more: bigframes.core.indexes.base.Index.astype

bigframes.core.indexes.base.Index.copy

copy(name: typing.Optional[typing.Hashable] = None)

Make a copy of this object.

See more: bigframes.core.indexes.base.Index.copy

bigframes.core.indexes.base.Index.drop

drop(labels: typing.Any) -> bigframes.core.indexes.base.Index

Make new Index with passed list of labels deleted.

See more: bigframes.core.indexes.base.Index.drop

bigframes.core.indexes.base.Index.drop_duplicates

drop_duplicates(*, keep: __builtins__.str = "first") -> Index

Return Index with duplicate values removed.

See more: bigframes.core.indexes.base.Index.drop_duplicates

bigframes.core.indexes.base.Index.dropna

dropna(
    how: typing.Literal["all", "any"] = "any",
) -> bigframes.core.indexes.base.Index

Return Index without NA/NaN values.

See more: bigframes.core.indexes.base.Index.dropna

bigframes.core.indexes.base.Index.fillna

fillna(value=None) -> bigframes.core.indexes.base.Index

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.core.indexes.base.Index.fillna

bigframes.core.indexes.base.Index.from_frame

from_frame(
    frame: typing.Union[bigframes.series.Series, bigframes.dataframe.DataFrame],
) -> bigframes.core.indexes.base.Index

Make a MultiIndex from a DataFrame.

See more: bigframes.core.indexes.base.Index.from_frame

bigframes.core.indexes.base.Index.get_level_values

get_level_values(level) -> bigframes.core.indexes.base.Index

Return an Index of values for requested level.

See more: bigframes.core.indexes.base.Index.get_level_values

bigframes.core.indexes.base.Index.get_loc

get_loc(key) -> typing.Union[int, slice, bigframes.series.Series]

Get integer location, slice or boolean mask for requested label.

See more: bigframes.core.indexes.base.Index.get_loc

bigframes.core.indexes.base.Index.isin

isin(values) -> bigframes.core.indexes.base.Index

Return a boolean array where the index values are in values.

See more: bigframes.core.indexes.base.Index.isin

bigframes.core.indexes.base.Index.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.core.indexes.base.Index.item

bigframes.core.indexes.base.Index.max

max() -> typing.Any

Return the maximum value of the Index.

See more: bigframes.core.indexes.base.Index.max

bigframes.core.indexes.base.Index.min

min() -> typing.Any

Return the minimum value of the Index.

See more: bigframes.core.indexes.base.Index.min

bigframes.core.indexes.base.Index.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.core.indexes.base.Index.nunique

bigframes.core.indexes.base.Index.rename

Alter Index or MultiIndex name.

See more: bigframes.core.indexes.base.Index.rename

bigframes.core.indexes.base.Index.sort_values

sort_values(
    *,
    inplace: bool = False,
    ascending: bool = True,
    na_position: __builtins__.str = "last"
) -> Index

Return a sorted copy of the index.

See more: bigframes.core.indexes.base.Index.sort_values

bigframes.core.indexes.base.Index.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

API documentation for to_list method.

See more: bigframes.core.indexes.base.Index.to_list

bigframes.core.indexes.base.Index.to_numpy

to_numpy(dtype=None, *, allow_large_results=None, **kwargs) -> numpy.ndarray

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

See more: bigframes.core.indexes.base.Index.to_numpy

bigframes.core.indexes.base.Index.to_pandas

Gets the Index as a pandas Index.

See more: bigframes.core.indexes.base.Index.to_pandas

bigframes.core.indexes.base.Index.to_series

to_series(
    index: typing.Optional[bigframes.core.indexes.base.Index] = None,
    name: typing.Optional[typing.Hashable] = None,
) -> bigframes.series.Series

Create a Series with both index and values equal to the index keys.

See more: bigframes.core.indexes.base.Index.to_series

bigframes.core.indexes.base.Index.transpose

transpose() -> bigframes.core.indexes.base.Index

Return the transpose, which is by definition self.

See more: bigframes.core.indexes.base.Index.transpose

bigframes.core.indexes.base.Index.unique

unique(
    level: typing.Optional[typing.Union[typing.Hashable, int]] = None,
) -> bigframes.core.indexes.base.Index

Returns unique values in the index.

See more: bigframes.core.indexes.base.Index.unique

bigframes.core.indexes.base.Index.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.core.indexes.base.Index.value_counts

bigframes.core.indexes.datetimes.DatetimeIndex.setitem

__setitem__(key, value) -> None

Index objects are immutable.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.setitem

bigframes.core.indexes.datetimes.DatetimeIndex.all

all() -> bool

Return whether all elements are Truthy.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.all

bigframes.core.indexes.datetimes.DatetimeIndex.any

any() -> bool

Return whether any element is Truthy.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.any

bigframes.core.indexes.datetimes.DatetimeIndex.argmax

argmax() -> int

Return int position of the largest value in the Series.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.argmax

bigframes.core.indexes.datetimes.DatetimeIndex.argmin

argmin() -> int

Return int position of the smallest value in the series.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.argmin

bigframes.core.indexes.datetimes.DatetimeIndex.astype

astype(
    dtype, *, errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.core.indexes.base.Index

Create an Index with values cast to dtypes.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.astype

bigframes.core.indexes.datetimes.DatetimeIndex.copy

copy(name: typing.Optional[typing.Hashable] = None)

Make a copy of this object.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.copy

bigframes.core.indexes.datetimes.DatetimeIndex.drop

drop(labels: typing.Any) -> bigframes.core.indexes.base.Index

Make new Index with passed list of labels deleted.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.drop

bigframes.core.indexes.datetimes.DatetimeIndex.drop_duplicates

drop_duplicates(*, keep: __builtins__.str = "first") -> Index

Return Index with duplicate values removed.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.drop_duplicates

bigframes.core.indexes.datetimes.DatetimeIndex.dropna

dropna(
    how: typing.Literal["all", "any"] = "any",
) -> bigframes.core.indexes.base.Index

Return Index without NA/NaN values.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.dropna

bigframes.core.indexes.datetimes.DatetimeIndex.fillna

fillna(value=None) -> bigframes.core.indexes.base.Index

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.fillna

bigframes.core.indexes.datetimes.DatetimeIndex.from_frame

from_frame(
    frame: typing.Union[bigframes.series.Series, bigframes.dataframe.DataFrame],
) -> bigframes.core.indexes.base.Index

Make a MultiIndex from a DataFrame.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.from_frame

bigframes.core.indexes.datetimes.DatetimeIndex.get_level_values

get_level_values(level) -> bigframes.core.indexes.base.Index

Return an Index of values for requested level.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.get_level_values

bigframes.core.indexes.datetimes.DatetimeIndex.get_loc

get_loc(key) -> typing.Union[int, slice, bigframes.series.Series]

Get integer location, slice or boolean mask for requested label.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.get_loc

bigframes.core.indexes.datetimes.DatetimeIndex.isin

isin(values) -> bigframes.core.indexes.base.Index

Return a boolean array where the index values are in values.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.isin

bigframes.core.indexes.datetimes.DatetimeIndex.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.item

bigframes.core.indexes.datetimes.DatetimeIndex.max

max() -> typing.Any

Return the maximum value of the Index.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.max

bigframes.core.indexes.datetimes.DatetimeIndex.min

min() -> typing.Any

Return the minimum value of the Index.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.min

bigframes.core.indexes.datetimes.DatetimeIndex.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.nunique

bigframes.core.indexes.datetimes.DatetimeIndex.rename

rename(
    name: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    *,
    inplace: bool = False
) -> typing.Optional[bigframes.core.indexes.base.Index]

Alter Index or MultiIndex name.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.rename

bigframes.core.indexes.datetimes.DatetimeIndex.sort_values

sort_values(
    *,
    inplace: bool = False,
    ascending: bool = True,
    na_position: __builtins__.str = "last"
) -> Index

Return a sorted copy of the index.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.sort_values

bigframes.core.indexes.datetimes.DatetimeIndex.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

API documentation for to_list method.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.to_list

bigframes.core.indexes.datetimes.DatetimeIndex.to_numpy

to_numpy(dtype=None, *, allow_large_results=None, **kwargs) -> numpy.ndarray

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

See more: bigframes.core.indexes.datetimes.DatetimeIndex.to_numpy

bigframes.core.indexes.datetimes.DatetimeIndex.to_pandas

to_pandas(
    *, allow_large_results: typing.Optional[bool] = None, dry_run: bool = False
) -> pandas.core.indexes.base.Index | pandas.core.series.Series

Gets the Index as a pandas Index.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.to_pandas

bigframes.core.indexes.datetimes.DatetimeIndex.to_series

to_series(
    index: typing.Optional[bigframes.core.indexes.base.Index] = None,
    name: typing.Optional[typing.Hashable] = None,
) -> bigframes.series.Series

Create a Series with both index and values equal to the index keys.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.to_series

bigframes.core.indexes.datetimes.DatetimeIndex.transpose

transpose() -> bigframes.core.indexes.base.Index

Return the transpose, which is by definition self.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.transpose

bigframes.core.indexes.datetimes.DatetimeIndex.unique

unique(
    level: typing.Optional[typing.Union[typing.Hashable, int]] = None,
) -> bigframes.core.indexes.base.Index

Returns unique values in the index.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.unique

bigframes.core.indexes.datetimes.DatetimeIndex.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.core.indexes.datetimes.DatetimeIndex.value_counts

bigframes.core.indexes.multi.MultiIndex.setitem

__setitem__(key, value) -> None

Index objects are immutable.

See more: bigframes.core.indexes.multi.MultiIndex.setitem

bigframes.core.indexes.multi.MultiIndex.all

all() -> bool

Return whether all elements are Truthy.

See more: bigframes.core.indexes.multi.MultiIndex.all

bigframes.core.indexes.multi.MultiIndex.any

any() -> bool

Return whether any element is Truthy.

See more: bigframes.core.indexes.multi.MultiIndex.any

bigframes.core.indexes.multi.MultiIndex.argmax

argmax() -> int

Return int position of the largest value in the Series.

See more: bigframes.core.indexes.multi.MultiIndex.argmax

bigframes.core.indexes.multi.MultiIndex.argmin

argmin() -> int

Return int position of the smallest value in the series.

See more: bigframes.core.indexes.multi.MultiIndex.argmin

bigframes.core.indexes.multi.MultiIndex.astype

astype(
    dtype, *, errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.core.indexes.base.Index

Create an Index with values cast to dtypes.

See more: bigframes.core.indexes.multi.MultiIndex.astype

bigframes.core.indexes.multi.MultiIndex.copy

copy(name: typing.Optional[typing.Hashable] = None)

Make a copy of this object.

See more: bigframes.core.indexes.multi.MultiIndex.copy

bigframes.core.indexes.multi.MultiIndex.drop

drop(labels: typing.Any) -> bigframes.core.indexes.base.Index

Make new Index with passed list of labels deleted.

See more: bigframes.core.indexes.multi.MultiIndex.drop

bigframes.core.indexes.multi.MultiIndex.drop_duplicates

drop_duplicates(*, keep: __builtins__.str = "first") -> Index

Return Index with duplicate values removed.

See more: bigframes.core.indexes.multi.MultiIndex.drop_duplicates

bigframes.core.indexes.multi.MultiIndex.dropna

dropna(
    how: typing.Literal["all", "any"] = "any",
) -> bigframes.core.indexes.base.Index

Return Index without NA/NaN values.

See more: bigframes.core.indexes.multi.MultiIndex.dropna

bigframes.core.indexes.multi.MultiIndex.fillna

fillna(value=None) -> bigframes.core.indexes.base.Index

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.core.indexes.multi.MultiIndex.fillna

bigframes.core.indexes.multi.MultiIndex.from_arrays

from_arrays(
    arrays,
    sortorder: int | None = None,
    names=None,
    *,
    session: Optional[bigframes.session.Session] = None
) -> MultiIndex

Convert arrays to MultiIndex.

See more: bigframes.core.indexes.multi.MultiIndex.from_arrays

bigframes.core.indexes.multi.MultiIndex.from_frame

from_frame(
    frame: typing.Union[bigframes.series.Series, bigframes.dataframe.DataFrame],
) -> bigframes.core.indexes.base.Index

Make a MultiIndex from a DataFrame.

See more: bigframes.core.indexes.multi.MultiIndex.from_frame

bigframes.core.indexes.multi.MultiIndex.from_tuples

from_tuples(
    tuples: Iterable[tuple[Hashable, ...]],
    sortorder: int | None = None,
    names: Sequence[Hashable] | Hashable | None = None,
    *,
    session: Optional[bigframes.session.Session] = None
) -> MultiIndex

Convert list of tuples to MultiIndex.

See more: bigframes.core.indexes.multi.MultiIndex.from_tuples

bigframes.core.indexes.multi.MultiIndex.get_level_values

get_level_values(level) -> bigframes.core.indexes.base.Index

Return an Index of values for requested level.

See more: bigframes.core.indexes.multi.MultiIndex.get_level_values

bigframes.core.indexes.multi.MultiIndex.get_loc

get_loc(key) -> typing.Union[int, slice, bigframes.series.Series]

Get integer location, slice or boolean mask for requested label.

See more: bigframes.core.indexes.multi.MultiIndex.get_loc

bigframes.core.indexes.multi.MultiIndex.isin

isin(values) -> bigframes.core.indexes.base.Index

Return a boolean array where the index values are in values.

See more: bigframes.core.indexes.multi.MultiIndex.isin

bigframes.core.indexes.multi.MultiIndex.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.core.indexes.multi.MultiIndex.item

bigframes.core.indexes.multi.MultiIndex.max

max() -> typing.Any

Return the maximum value of the Index.

See more: bigframes.core.indexes.multi.MultiIndex.max

bigframes.core.indexes.multi.MultiIndex.min

min() -> typing.Any

Return the minimum value of the Index.

See more: bigframes.core.indexes.multi.MultiIndex.min

bigframes.core.indexes.multi.MultiIndex.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.core.indexes.multi.MultiIndex.nunique

bigframes.core.indexes.multi.MultiIndex.rename

rename(
    name: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    *,
    inplace: bool = False
) -> typing.Optional[bigframes.core.indexes.base.Index]

Alter Index or MultiIndex name.

See more: bigframes.core.indexes.multi.MultiIndex.rename

bigframes.core.indexes.multi.MultiIndex.sort_values

sort_values(
    *,
    inplace: bool = False,
    ascending: bool = True,
    na_position: __builtins__.str = "last"
) -> Index

Return a sorted copy of the index.

See more: bigframes.core.indexes.multi.MultiIndex.sort_values

bigframes.core.indexes.multi.MultiIndex.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

API documentation for to_list method.

See more: bigframes.core.indexes.multi.MultiIndex.to_list

bigframes.core.indexes.multi.MultiIndex.to_numpy

to_numpy(dtype=None, *, allow_large_results=None, **kwargs) -> numpy.ndarray

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

See more: bigframes.core.indexes.multi.MultiIndex.to_numpy

bigframes.core.indexes.multi.MultiIndex.to_pandas

to_pandas(
    *, allow_large_results: typing.Optional[bool] = None, dry_run: bool = False
) -> pandas.core.indexes.base.Index | pandas.core.series.Series

Gets the Index as a pandas Index.

See more: bigframes.core.indexes.multi.MultiIndex.to_pandas

bigframes.core.indexes.multi.MultiIndex.to_series

to_series(
    index: typing.Optional[bigframes.core.indexes.base.Index] = None,
    name: typing.Optional[typing.Hashable] = None,
) -> bigframes.series.Series

Create a Series with both index and values equal to the index keys.

See more: bigframes.core.indexes.multi.MultiIndex.to_series

bigframes.core.indexes.multi.MultiIndex.transpose

transpose() -> bigframes.core.indexes.base.Index

Return the transpose, which is by definition self.

See more: bigframes.core.indexes.multi.MultiIndex.transpose

bigframes.core.indexes.multi.MultiIndex.unique

unique(
    level: typing.Optional[typing.Union[typing.Hashable, int]] = None,
) -> bigframes.core.indexes.base.Index

Returns unique values in the index.

See more: bigframes.core.indexes.multi.MultiIndex.unique

bigframes.core.indexes.multi.MultiIndex.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.core.indexes.multi.MultiIndex.value_counts

bigframes.core.window.Window.count

count()

Calculate the window count of non-NULL observations.

See more: bigframes.core.window.Window.count

bigframes.core.window.Window.max

max()

Calculate the weighted window maximum.

See more: bigframes.core.window.Window.max

bigframes.core.window.Window.mean

mean()

Calculate the weighted window mean.

See more: bigframes.core.window.Window.mean

bigframes.core.window.Window.min

min()

Calculate the weighted window minimum.

See more: bigframes.core.window.Window.min

bigframes.core.window.Window.std

std()

Calculate the weighted window standard deviation.

See more: bigframes.core.window.Window.std

bigframes.core.window.Window.sum

sum()

Calculate the weighted window sum.

See more: bigframes.core.window.Window.sum

bigframes.core.window.Window.var

var()

Calculate the weighted window variance.

See more: bigframes.core.window.Window.var

bigframes.dataframe.DataFrame.abs

__abs__() -> bigframes.dataframe.DataFrame

Return the absolute value of the argument.

See more: bigframes.dataframe.DataFrame.abs

bigframes.dataframe.DataFrame.add

__add__(other) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, column-wise, using arithmetic operator +.

See more: bigframes.dataframe.DataFrame.add

bigframes.dataframe.DataFrame.and

__and__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise AND of DataFrame and other, element-wise, using operator &.

See more: bigframes.dataframe.DataFrame.and

bigframes.dataframe.DataFrame.array

__array__(dtype=None, copy: typing.Optional[bool] = None) -> numpy.ndarray

Returns the rows as NumPy array.

See more: bigframes.dataframe.DataFrame.array

bigframes.dataframe.DataFrame.__array_ufunc__

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

Used to support numpy ufuncs.

See more: bigframes.dataframe.DataFrame.array_ufunc

bigframes.dataframe.DataFrame.bool

__bool__()

Returns the truth value of the object.

See more: bigframes.dataframe.DataFrame.bool

bigframes.dataframe.DataFrame.eq

__eq__(other) -> bigframes.dataframe.DataFrame

Check equality of DataFrame and other, element-wise, using logical operator ==.

See more: bigframes.dataframe.DataFrame.eq

bigframes.dataframe.DataFrame.floordiv

__floordiv__(other)

Get integer division of DataFrame by other, using arithmetic operator //.

See more: bigframes.dataframe.DataFrame.floordiv

bigframes.dataframe.DataFrame.ge

__ge__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is greater than or equal to other, element-wise, using logical operator >=.

See more: bigframes.dataframe.DataFrame.ge

bigframes.dataframe.DataFrame.getitem

Gets the specified column(s) from the DataFrame.

See more: bigframes.dataframe.DataFrame.getitem

bigframes.dataframe.DataFrame.gt

__gt__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is greater than other, element-wise, using logical operator >.

See more: bigframes.dataframe.DataFrame.gt

bigframes.dataframe.DataFrame.invert

__invert__() -> bigframes.dataframe.DataFrame

Returns the bitwise inversion of the DataFrame, element-wise using operator ````.

See more: bigframes.dataframe.DataFrame.invert

bigframes.dataframe.DataFrame.le

__le__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is less than or equal to other, element-wise, using logical operator <=.

See more: bigframes.dataframe.DataFrame.le

bigframes.dataframe.DataFrame.len

__len__()

Returns number of rows in the DataFrame, serves len operator.

See more: bigframes.dataframe.DataFrame.len

bigframes.dataframe.DataFrame.lt

__lt__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is less than other, element-wise, using logical operator <.

See more: bigframes.dataframe.DataFrame.lt

bigframes.dataframe.DataFrame.matmul

__matmul__(other) -> bigframes.dataframe.DataFrame

Compute the matrix multiplication between the DataFrame and other, using operator @.

See more: bigframes.dataframe.DataFrame.matmul

bigframes.dataframe.DataFrame.mod

__mod__(other)

Get modulo of DataFrame with other, element-wise, using operator %.

See more: bigframes.dataframe.DataFrame.mod

bigframes.dataframe.DataFrame.mul

__mul__(other)

Get multiplication of DataFrame with other, element-wise, using operator *.

See more: bigframes.dataframe.DataFrame.mul

bigframes.dataframe.DataFrame.ne

__ne__(other) -> bigframes.dataframe.DataFrame

Check inequality of DataFrame and other, element-wise, using logical operator !=.

See more: bigframes.dataframe.DataFrame.ne

bigframes.dataframe.DataFrame.nonzero

__nonzero__()

Returns the truth value of the object.

See more: bigframes.dataframe.DataFrame.nonzero

bigframes.dataframe.DataFrame.or

__or__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise OR of DataFrame and other, element-wise, using operator |.

See more: bigframes.dataframe.DataFrame.or

bigframes.dataframe.DataFrame.pow

__pow__(other)

Get exponentiation of DataFrame with other, element-wise, using operator **.

See more: bigframes.dataframe.DataFrame.pow

bigframes.dataframe.DataFrame.radd

__radd__(other) -> bigframes.dataframe.DataFrame

Get addition of other and DataFrame, element-wise (binary operator +).

See more: bigframes.dataframe.DataFrame.radd

bigframes.dataframe.DataFrame.rand

__rand__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise AND of DataFrame and other, element-wise, using operator &.

See more: bigframes.dataframe.DataFrame.rand

bigframes.dataframe.DataFrame.repr

__repr__() -> str

Converts a DataFrame to a string.

See more: bigframes.dataframe.DataFrame.repr

bigframes.dataframe.DataFrame.rfloordiv

__rfloordiv__(other)

Get integer divison of other by DataFrame.

See more: bigframes.dataframe.DataFrame.rfloordiv

bigframes.dataframe.DataFrame.rmod

__rmod__(other)

Get integer divison of other by DataFrame.

See more: bigframes.dataframe.DataFrame.rmod

bigframes.dataframe.DataFrame.rmul

__rmul__(other)

Get multiplication of DataFrame with other, element-wise, using operator *.

See more: bigframes.dataframe.DataFrame.rmul

bigframes.dataframe.DataFrame.ror

__ror__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise OR of DataFrame and other, element-wise, using operator |.

See more: bigframes.dataframe.DataFrame.ror

bigframes.dataframe.DataFrame.rpow

__rpow__(other)

Get exponentiation of other with DataFrame, element-wise, using operator **.

See more: bigframes.dataframe.DataFrame.rpow

bigframes.dataframe.DataFrame.rsub

__rsub__(other)

Get subtraction of DataFrame from other, element-wise, using operator -.

See more: bigframes.dataframe.DataFrame.rsub

bigframes.dataframe.DataFrame.rtruediv

__rtruediv__(other)

Get division of other by DataFrame, element-wise, using operator /.

See more: bigframes.dataframe.DataFrame.rtruediv

bigframes.dataframe.DataFrame.rxor

__rxor__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise XOR of DataFrame and other, element-wise, using operator ^.

See more: bigframes.dataframe.DataFrame.rxor

bigframes.dataframe.DataFrame.setitem

__setitem__(
    key: str | list[str] | pandas.Index, value: SingleItemValue | MultiItemValue
)

Modify or insert a column into the DataFrame.

See more: bigframes.dataframe.DataFrame.setitem

bigframes.dataframe.DataFrame.sub

__sub__(other)

Get subtraction of other from DataFrame, element-wise, using operator -.

See more: bigframes.dataframe.DataFrame.sub

bigframes.dataframe.DataFrame.truediv

__truediv__(other)

Get division of DataFrame by other, element-wise, using operator /.

See more: bigframes.dataframe.DataFrame.truediv

bigframes.dataframe.DataFrame.xor

__xor__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise XOR of DataFrame and other, element-wise, using operator ^.

See more: bigframes.dataframe.DataFrame.xor

bigframes.dataframe.DataFrame.abs

abs() -> bigframes.dataframe.DataFrame

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

See more: bigframes.dataframe.DataFrame.abs

bigframes.dataframe.DataFrame.add

add(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, element-wise (binary operator +).

See more: bigframes.dataframe.DataFrame.add

bigframes.dataframe.DataFrame.add_prefix

add_prefix(
    prefix: str, axis: int | str | None = None
) -> bigframes.dataframe.DataFrame

Prefix labels with string prefix.

See more: bigframes.dataframe.DataFrame.add_prefix

bigframes.dataframe.DataFrame.add_suffix

add_suffix(
    suffix: str, axis: int | str | None = None
) -> bigframes.dataframe.DataFrame

Suffix labels with string suffix.

See more: bigframes.dataframe.DataFrame.add_suffix

bigframes.dataframe.DataFrame.agg

agg(func) -> bigframes.dataframe.DataFrame | bigframes.series.Series

Aggregate using one or more operations over columns.

See more: bigframes.dataframe.DataFrame.agg

bigframes.dataframe.DataFrame.aggregate

aggregate(func) -> bigframes.dataframe.DataFrame | bigframes.series.Series

Aggregate using one or more operations over columns.

See more: bigframes.dataframe.DataFrame.aggregate

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.align

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.all

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.any

bigframes.dataframe.DataFrame.apply

apply(func, *, axis=0, args: typing.Tuple = (), **kwargs)

Apply a function along an axis of the DataFrame.

See more: bigframes.dataframe.DataFrame.apply

bigframes.dataframe.DataFrame.applymap

applymap(
    func, na_action: typing.Optional[str] = None
) -> bigframes.dataframe.DataFrame

Apply a function to a Dataframe elementwise.

See more: bigframes.dataframe.DataFrame.applymap

bigframes.dataframe.DataFrame.area

area(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    stacked: bool = True,
    **kwargs
)

Draw a stacked area plot.

See more: bigframes.dataframe.DataFrame.area

bigframes.dataframe.DataFrame.assign

assign(**kwargs) -> bigframes.dataframe.DataFrame

Assign new columns to a DataFrame.

See more: bigframes.dataframe.DataFrame.assign

bigframes.dataframe.DataFrame.astype

astype(
    dtype: typing.Union[
        typing.Literal[
            "boolean",
            "Float64",
            "Int64",
            "int64[pyarrow]",
            "string",
            "string[pyarrow]",
            "timestamp[us, tz=UTC][pyarrow]",
            "timestamp[us][pyarrow]",
            "date32[day][pyarrow]",
            "time64[us][pyarrow]",
            "decimal128(38, 9)[pyarrow]",
            "decimal256(76, 38)[pyarrow]",
            "binary[pyarrow]",
            "duration[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,
        geopandas.array.GeometryDtype,
        type,
        dict[
            str,
            typing.Union[
                typing.Literal[
                    "boolean",
                    "Float64",
                    "Int64",
                    "int64[pyarrow]",
                    "string",
                    "string[pyarrow]",
                    "timestamp[us, tz=UTC][pyarrow]",
                    "timestamp[us][pyarrow]",
                    "date32[day][pyarrow]",
                    "time64[us][pyarrow]",
                    "decimal128(38, 9)[pyarrow]",
                    "decimal256(76, 38)[pyarrow]",
                    "binary[pyarrow]",
                    "duration[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,
                geopandas.array.GeometryDtype,
            ],
        ],
    ],
    *,
    errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.dataframe.DataFrame

Cast a pandas object to a specified dtype dtype.

See more: bigframes.dataframe.DataFrame.astype

bigframes.dataframe.DataFrame.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.dataframe.DataFrame.bar

bigframes.dataframe.DataFrame.bfill

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

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

See more: bigframes.dataframe.DataFrame.bfill

bigframes.dataframe.DataFrame.cache

cache()

Materializes the DataFrame to a temporary table.

See more: bigframes.dataframe.DataFrame.cache

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.combine

bigframes.dataframe.DataFrame.combine_first

combine_first(other: bigframes.dataframe.DataFrame)

Update null elements with value in the same location in other.

See more: bigframes.dataframe.DataFrame.combine_first

bigframes.dataframe.DataFrame.copy

copy() -> bigframes.dataframe.DataFrame

Make a copy of this object's indices and data.

See more: bigframes.dataframe.DataFrame.copy

bigframes.dataframe.DataFrame.corr

corr(
    method="pearson", min_periods=None, numeric_only=False
) -> bigframes.dataframe.DataFrame

Compute pairwise correlation of columns, excluding NA/null values.

See more: bigframes.dataframe.DataFrame.corr

bigframes.dataframe.DataFrame.corrwith

corrwith(
    other: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    numeric_only: bool = False
)

Compute pairwise correlation.

See more: bigframes.dataframe.DataFrame.corrwith

bigframes.dataframe.DataFrame.count

count(*, numeric_only: bool = False) -> bigframes.series.Series

Count non-NA cells for each column.

See more: bigframes.dataframe.DataFrame.count

bigframes.dataframe.DataFrame.cov

cov(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute pairwise covariance of columns, excluding NA/null values.

See more: bigframes.dataframe.DataFrame.cov

bigframes.dataframe.DataFrame.cummax

cummax() -> bigframes.dataframe.DataFrame

Return cumulative maximum over columns.

See more: bigframes.dataframe.DataFrame.cummax

bigframes.dataframe.DataFrame.cummin

cummin() -> bigframes.dataframe.DataFrame

Return cumulative minimum over columns.

See more: bigframes.dataframe.DataFrame.cummin

bigframes.dataframe.DataFrame.cumprod

cumprod() -> bigframes.dataframe.DataFrame

Return cumulative product over columns.

See more: bigframes.dataframe.DataFrame.cumprod

bigframes.dataframe.DataFrame.cumsum

cumsum()

Return cumulative sum over columns.

See more: bigframes.dataframe.DataFrame.cumsum

bigframes.dataframe.DataFrame.describe

describe(
    include: typing.Union[None, typing.Literal["all"]] = None,
) -> bigframes.dataframe.DataFrame

Generate descriptive statistics.

See more: bigframes.dataframe.DataFrame.describe

bigframes.dataframe.DataFrame.diff

diff(periods: int = 1) -> bigframes.dataframe.DataFrame

First discrete difference of element.

See more: bigframes.dataframe.DataFrame.diff

bigframes.dataframe.DataFrame.div

div(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.dataframe.DataFrame.div

bigframes.dataframe.DataFrame.divide

divide(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.dataframe.DataFrame.divide

bigframes.dataframe.DataFrame.dot

dot(other: _DataFrameOrSeries) -> _DataFrameOrSeries

Compute the matrix multiplication between the DataFrame and other.

See more: bigframes.dataframe.DataFrame.dot

bigframes.dataframe.DataFrame.drop

Drop specified labels from columns.

See more: bigframes.dataframe.DataFrame.drop

bigframes.dataframe.DataFrame.drop_duplicates

drop_duplicates(
    subset: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    *,
    keep: str = "first"
) -> bigframes.dataframe.DataFrame

Return DataFrame with duplicate rows removed.

See more: bigframes.dataframe.DataFrame.drop_duplicates

bigframes.dataframe.DataFrame.droplevel

droplevel(
    level: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    axis: int | str = 0,
)

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

See more: bigframes.dataframe.DataFrame.droplevel

bigframes.dataframe.DataFrame.dropna

dropna(
    *,
    axis: int | str = 0,
    how: str = "any",
    thresh: typing.Optional[int] = None,
    subset: typing.Union[
        None, typing.Hashable, typing.Sequence[typing.Hashable]
    ] = None,
    inplace: bool = False,
    ignore_index=False
) -> bigframes.dataframe.DataFrame

Remove missing values.

See more: bigframes.dataframe.DataFrame.dropna

bigframes.dataframe.DataFrame.duplicated

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

Return boolean Series denoting duplicate rows.

See more: bigframes.dataframe.DataFrame.duplicated

bigframes.dataframe.DataFrame.eq

eq(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get equal to of DataFrame and other, element-wise (binary operator eq).

See more: bigframes.dataframe.DataFrame.eq

bigframes.dataframe.DataFrame.equals

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

Test whether two objects contain the same elements.

See more: bigframes.dataframe.DataFrame.equals

bigframes.dataframe.DataFrame.eval

eval(expr: str) -> bigframes.dataframe.DataFrame

Evaluate a string describing operations on DataFrame columns.

See more: bigframes.dataframe.DataFrame.eval

bigframes.dataframe.DataFrame.expanding

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

Provide expanding window calculations.

See more: bigframes.dataframe.DataFrame.expanding

bigframes.dataframe.DataFrame.explode

explode(
    column: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    *,
    ignore_index: typing.Optional[bool] = False
) -> bigframes.dataframe.DataFrame

Transform each element of an array to a row, replicating index values.

See more: bigframes.dataframe.DataFrame.explode

bigframes.dataframe.DataFrame.ffill

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

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

See more: bigframes.dataframe.DataFrame.ffill

bigframes.dataframe.DataFrame.fillna

fillna(value=None) -> bigframes.dataframe.DataFrame

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.dataframe.DataFrame.fillna

bigframes.dataframe.DataFrame.filter

filter(
    items: typing.Optional[typing.Iterable] = None,
    like: typing.Optional[str] = None,
    regex: typing.Optional[str] = None,
    axis: int | str | None = None,
) -> bigframes.dataframe.DataFrame

Subset the dataframe rows or columns according to the specified index labels.

See more: bigframes.dataframe.DataFrame.filter

bigframes.dataframe.DataFrame.first_valid_index

first_valid_index()

API documentation for first_valid_index method.

See more: bigframes.dataframe.DataFrame.first_valid_index

bigframes.dataframe.DataFrame.floordiv

floordiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get integer division of DataFrame and other, element-wise (binary operator //).

See more: bigframes.dataframe.DataFrame.floordiv

bigframes.dataframe.DataFrame.from_dict

from_dict(
    data: dict, orient: str = "columns", dtype=None, columns=None
) -> bigframes.dataframe.DataFrame

Construct DataFrame from dict of array-like or dicts.

See more: bigframes.dataframe.DataFrame.from_dict

bigframes.dataframe.DataFrame.from_records

from_records(
    data,
    index=None,
    exclude=None,
    columns=None,
    coerce_float: bool = False,
    nrows: typing.Optional[int] = None,
) -> bigframes.dataframe.DataFrame

Convert structured or record ndarray to DataFrame.

See more: bigframes.dataframe.DataFrame.from_records

bigframes.dataframe.DataFrame.ge

ge(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.dataframe.DataFrame.ge

bigframes.dataframe.DataFrame.get

get(key, default=None)

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

See more: bigframes.dataframe.DataFrame.get

bigframes.dataframe.DataFrame.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[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    as_index: bool = True,
    dropna: bool = True
) -> bigframes.core.groupby.dataframe_group_by.DataFrameGroupBy

Group DataFrame by columns.

See more: bigframes.dataframe.DataFrame.groupby

bigframes.dataframe.DataFrame.gt

gt(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get 'greater than' of DataFrame and other, element-wise (binary operator >).

See more: bigframes.dataframe.DataFrame.gt

bigframes.dataframe.DataFrame.head

head(n: int = 5) -> bigframes.dataframe.DataFrame

Return the first n rows.

See more: bigframes.dataframe.DataFrame.head

bigframes.dataframe.DataFrame.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.dataframe.DataFrame.hist

bigframes.dataframe.DataFrame.idxmax

idxmax() -> bigframes.series.Series

Return index of first occurrence of maximum over columns.

See more: bigframes.dataframe.DataFrame.idxmax

bigframes.dataframe.DataFrame.idxmin

idxmin() -> bigframes.series.Series

Return index of first occurrence of minimum over columns.

See more: bigframes.dataframe.DataFrame.idxmin

bigframes.dataframe.DataFrame.info

info(
    verbose: typing.Optional[bool] = None,
    buf=None,
    max_cols: typing.Optional[int] = None,
    memory_usage: typing.Optional[bool] = None,
    show_counts: typing.Optional[bool] = None,
)

Print a concise summary of a DataFrame.

See more: bigframes.dataframe.DataFrame.info

bigframes.dataframe.DataFrame.insert

insert(
    loc: int,
    column: blocks.Label,
    value: SingleItemValue,
    allow_duplicates: bool = False,
)

Insert column into DataFrame at specified location.

See more: bigframes.dataframe.DataFrame.insert

bigframes.dataframe.DataFrame.interpolate

interpolate(method: str = "linear") -> bigframes.dataframe.DataFrame

Fill NA (NULL in BigQuery) values using an interpolation method.

See more: bigframes.dataframe.DataFrame.interpolate

bigframes.dataframe.DataFrame.isin

isin(values) -> bigframes.dataframe.DataFrame

Whether each element in the DataFrame is contained in values.

See more: bigframes.dataframe.DataFrame.isin

bigframes.dataframe.DataFrame.isna

isna() -> bigframes.dataframe.DataFrame

Detect missing (NULL) values.

See more: bigframes.dataframe.DataFrame.isna

bigframes.dataframe.DataFrame.isnull

isnull() -> bigframes.dataframe.DataFrame

Detect missing (NULL) values.

See more: bigframes.dataframe.DataFrame.isnull

bigframes.dataframe.DataFrame.items

items()

Iterate over (column name, Series) pairs.

See more: bigframes.dataframe.DataFrame.items

bigframes.dataframe.DataFrame.iterrows

iterrows() -> typing.Iterable[tuple[typing.Any, pandas.core.series.Series]]

Iterate over DataFrame rows as (index, Series) pairs.

See more: bigframes.dataframe.DataFrame.iterrows

bigframes.dataframe.DataFrame.itertuples

itertuples(
    index: bool = True, name: typing.Optional[str] = "Pandas"
) -> typing.Iterable[tuple[typing.Any, ...]]

Iterate over DataFrame rows as namedtuples.

See more: bigframes.dataframe.DataFrame.itertuples

bigframes.dataframe.DataFrame.join

join(
    other: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    on: typing.Optional[str] = None,
    how: str = "left",
    lsuffix: str = "",
    rsuffix: str = "",
) -> bigframes.dataframe.DataFrame

Join columns of another DataFrame.

See more: bigframes.dataframe.DataFrame.join

bigframes.dataframe.DataFrame.keys

keys() -> pandas.core.indexes.base.Index

Get the 'info axis'.

See more: bigframes.dataframe.DataFrame.keys

bigframes.dataframe.DataFrame.kurt

kurt(*, numeric_only: bool = False)

Return unbiased kurtosis over columns.

See more: bigframes.dataframe.DataFrame.kurt

bigframes.dataframe.DataFrame.kurtosis

kurtosis(*, numeric_only: bool = False)

Return unbiased kurtosis over columns.

See more: bigframes.dataframe.DataFrame.kurtosis

bigframes.dataframe.DataFrame.le

le(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.dataframe.DataFrame.le

bigframes.dataframe.DataFrame.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.dataframe.DataFrame.line

bigframes.dataframe.DataFrame.lt

lt(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.dataframe.DataFrame.lt

bigframes.dataframe.DataFrame.map

map(func, na_action: typing.Optional[str] = None) -> bigframes.dataframe.DataFrame

Apply a function to a Dataframe elementwise.

See more: bigframes.dataframe.DataFrame.map

bigframes.dataframe.DataFrame.mask

mask(cond, other=None)

Replace values where the condition is False.

See more: bigframes.dataframe.DataFrame.mask

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.

See more: bigframes.dataframe.DataFrame.max

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.mean

bigframes.dataframe.DataFrame.median

median(
    *, numeric_only: bool = False, exact: bool = True
) -> bigframes.series.Series

Return the median of the values over colunms.

See more: bigframes.dataframe.DataFrame.median

bigframes.dataframe.DataFrame.melt

melt(
    id_vars: typing.Optional[typing.Iterable[typing.Hashable]] = None,
    value_vars: typing.Optional[typing.Iterable[typing.Hashable]] = None,
    var_name: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    value_name: typing.Hashable = "value",
)

Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.

See more: bigframes.dataframe.DataFrame.melt

bigframes.dataframe.DataFrame.memory_usage

memory_usage(index: bool = True)

Return the memory usage of each column in bytes.

See more: bigframes.dataframe.DataFrame.memory_usage

bigframes.dataframe.DataFrame.merge

merge(
    right: bigframes.dataframe.DataFrame,
    how: typing.Literal["inner", "left", "outer", "right", "cross"] = "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,
    left_index: bool = False,
    right_index: bool = False,
    sort: bool = False,
    suffixes: tuple[str, str] = ("_x", "_y")
) -> bigframes.dataframe.DataFrame

Merge DataFrame objects with a database-style join.

See more: bigframes.dataframe.DataFrame.merge

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.

See more: bigframes.dataframe.DataFrame.min

bigframes.dataframe.DataFrame.mod

mod(
    other: int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get modulo of DataFrame and other, element-wise (binary operator %).

See more: bigframes.dataframe.DataFrame.mod

bigframes.dataframe.DataFrame.mul

mul(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.dataframe.DataFrame.mul

bigframes.dataframe.DataFrame.multiply

multiply(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.dataframe.DataFrame.multiply

bigframes.dataframe.DataFrame.ne

ne(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get not equal to of DataFrame and other, element-wise (binary operator ne).

See more: bigframes.dataframe.DataFrame.ne

bigframes.dataframe.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.

See more: bigframes.dataframe.DataFrame.nlargest

bigframes.dataframe.DataFrame.notna

notna() -> bigframes.dataframe.DataFrame

Detect existing (non-missing) values.

See more: bigframes.dataframe.DataFrame.notna

bigframes.dataframe.DataFrame.notnull

notnull() -> bigframes.dataframe.DataFrame

Detect existing (non-missing) values.

See more: bigframes.dataframe.DataFrame.notnull

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.nsmallest

bigframes.dataframe.DataFrame.nunique

nunique() -> bigframes.series.Series

Count number of distinct elements in each column.

See more: bigframes.dataframe.DataFrame.nunique

bigframes.dataframe.DataFrame.pct_change

pct_change(periods: int = 1) -> bigframes.dataframe.DataFrame

Fractional change between the current and a prior element.

See more: bigframes.dataframe.DataFrame.pct_change

bigframes.dataframe.DataFrame.peek

peek(
    n: int = 5, *, force: bool = True, allow_large_results=None
) -> pandas.core.frame.DataFrame

Preview n arbitrary rows from the dataframe.

See more: bigframes.dataframe.DataFrame.peek

bigframes.dataframe.DataFrame.pipe

pipe(func: Callable[..., T] | tuple[Callable[..., T], str], *args, **kwargs) -> T

Apply chainable functions that expect Series or DataFrames.

See more: bigframes.dataframe.DataFrame.pipe

bigframes.dataframe.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.

See more: bigframes.dataframe.DataFrame.pivot

bigframes.dataframe.DataFrame.pivot_table

pivot_table(
    values: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    index: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    columns: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    aggfunc: str = "mean",
) -> bigframes.dataframe.DataFrame

Create a spreadsheet-style pivot table as a DataFrame.

See more: bigframes.dataframe.DataFrame.pivot_table

bigframes.dataframe.DataFrame.pow

pow(
    other: int | bigframes.series.Series, axis: str | int = "columns"
) -> bigframes.dataframe.DataFrame

Get Exponential power of dataframe and other, element-wise (binary operator **).

See more: bigframes.dataframe.DataFrame.pow

bigframes.dataframe.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.

See more: bigframes.dataframe.DataFrame.prod

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.product

bigframes.dataframe.DataFrame.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5, *, numeric_only: bool = False
)

Return values at the given quantile over requested axis.

See more: bigframes.dataframe.DataFrame.quantile

bigframes.dataframe.DataFrame.query

query(expr: str) -> bigframes.dataframe.DataFrame

Query the columns of a DataFrame with a boolean expression.

See more: bigframes.dataframe.DataFrame.query

bigframes.dataframe.DataFrame.radd

radd(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, element-wise (binary operator +).

See more: bigframes.dataframe.DataFrame.radd

bigframes.dataframe.DataFrame.rank

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

Compute numerical data ranks (1 through n) along axis.

See more: bigframes.dataframe.DataFrame.rank

bigframes.dataframe.DataFrame.rdiv

rdiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.dataframe.DataFrame.rdiv

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.reindex

bigframes.dataframe.DataFrame.reindex_like

reindex_like(
    other: bigframes.dataframe.DataFrame, *, validate: typing.Optional[bool] = None
)

Return an object with matching indices as other object.

See more: bigframes.dataframe.DataFrame.reindex_like

bigframes.dataframe.DataFrame.rename

Rename columns.

See more: bigframes.dataframe.DataFrame.rename

bigframes.dataframe.DataFrame.rename_axis

Set the name of the axis for the index.

See more: bigframes.dataframe.DataFrame.rename_axis

bigframes.dataframe.DataFrame.reorder_levels

reorder_levels(
    order: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    axis: int | str = 0,
)

Rearrange index levels using input order.

See more: bigframes.dataframe.DataFrame.reorder_levels

bigframes.dataframe.DataFrame.replace

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

Replace values given in to_replace with value.

See more: bigframes.dataframe.DataFrame.replace

bigframes.dataframe.DataFrame.resample

resample(
    rule: str,
    *,
    closed: typing.Optional[typing.Literal["right", "left"]] = None,
    label: typing.Optional[typing.Literal["right", "left"]] = None,
    on: typing.Hashable = None,
    level: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    origin: typing.Union[
        pandas._libs.tslibs.timestamps.Timestamp,
        datetime.datetime,
        numpy.datetime64,
        int,
        float,
        str,
        typing.Literal["epoch", "start", "start_day", "end", "end_day"],
    ] = "start_day"
) -> bigframes.core.groupby.dataframe_group_by.DataFrameGroupBy

Resample time-series data.

See more: bigframes.dataframe.DataFrame.resample

bigframes.dataframe.DataFrame.reset_index

Reset the index.

See more: bigframes.dataframe.DataFrame.reset_index

bigframes.dataframe.DataFrame.rfloordiv

rfloordiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get integer division of DataFrame and other, element-wise (binary operator //).

See more: bigframes.dataframe.DataFrame.rfloordiv

bigframes.dataframe.DataFrame.rmod

rmod(
    other: int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get modulo of DataFrame and other, element-wise (binary operator %).

See more: bigframes.dataframe.DataFrame.rmod

bigframes.dataframe.DataFrame.rmul

rmul(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.dataframe.DataFrame.rmul

bigframes.dataframe.DataFrame.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods=None,
    on: str | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Provide rolling window calculations.

See more: bigframes.dataframe.DataFrame.rolling

bigframes.dataframe.DataFrame.round

round(
    decimals: typing.Union[int, dict[typing.Hashable, int]] = 0,
) -> bigframes.dataframe.DataFrame

Round a DataFrame to a variable number of decimal places.

See more: bigframes.dataframe.DataFrame.round

bigframes.dataframe.DataFrame.rpow

rpow(
    other: int | bigframes.series.Series, axis: str | int = "columns"
) -> bigframes.dataframe.DataFrame

Get Exponential power of dataframe and other, element-wise (binary operator rpow).

See more: bigframes.dataframe.DataFrame.rpow

bigframes.dataframe.DataFrame.rsub

rsub(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.dataframe.DataFrame.rsub

bigframes.dataframe.DataFrame.rtruediv

rtruediv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.dataframe.DataFrame.rtruediv

bigframes.dataframe.DataFrame.sample

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None,
    sort: typing.Optional[typing.Union[bool, typing.Literal["random"]]] = "random"
) -> bigframes.dataframe.DataFrame

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

See more: bigframes.dataframe.DataFrame.sample

bigframes.dataframe.DataFrame.scatter

scatter(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    s: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    c: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    **kwargs
)

Create a scatter plot with varying marker point size and color.

See more: bigframes.dataframe.DataFrame.scatter

bigframes.dataframe.DataFrame.select_dtypes

select_dtypes(include=None, exclude=None) -> bigframes.dataframe.DataFrame

Return a subset of the DataFrame's columns based on the column dtypes.

See more: bigframes.dataframe.DataFrame.select_dtypes

bigframes.dataframe.DataFrame.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.

See more: bigframes.dataframe.DataFrame.set_index

bigframes.dataframe.DataFrame.shift

shift(periods: int = 1) -> bigframes.dataframe.DataFrame

Shift index by desired number of periods.

See more: bigframes.dataframe.DataFrame.shift

bigframes.dataframe.DataFrame.skew

skew(*, numeric_only: bool = False)

Return unbiased skew over columns.

See more: bigframes.dataframe.DataFrame.skew

bigframes.dataframe.DataFrame.sort_index

Sort object by labels (along an axis).

See more: bigframes.dataframe.DataFrame.sort_index

bigframes.dataframe.DataFrame.sort_values

Sort by the values along row axis.

See more: bigframes.dataframe.DataFrame.sort_values

bigframes.dataframe.DataFrame.stack

stack(level: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = -1)

Stack the prescribed level(s) from columns to index.

See more: bigframes.dataframe.DataFrame.stack

bigframes.dataframe.DataFrame.std

std(
    axis: typing.Union[str, int] = 0, *, numeric_only: bool = False
) -> bigframes.series.Series

Return sample standard deviation over columns.

See more: bigframes.dataframe.DataFrame.std

bigframes.dataframe.DataFrame.sub

sub(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.dataframe.DataFrame.sub

bigframes.dataframe.DataFrame.subtract

subtract(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.dataframe.DataFrame.subtract

bigframes.dataframe.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.

See more: bigframes.dataframe.DataFrame.sum

bigframes.dataframe.DataFrame.swaplevel

swaplevel(i: int = -2, j: int = -1, axis: int | str = 0)

Swap levels i and j in a MultiIndex.

See more: bigframes.dataframe.DataFrame.swaplevel

bigframes.dataframe.DataFrame.tail

tail(n: int = 5) -> bigframes.dataframe.DataFrame

Return the last n rows.

See more: bigframes.dataframe.DataFrame.tail

bigframes.dataframe.DataFrame.take

take(
    indices: typing.Sequence[int], axis: int | str | None = 0, **kwargs
) -> bigframes.dataframe.DataFrame

Return the elements in the given positional indices along an axis.

See more: bigframes.dataframe.DataFrame.take

bigframes.dataframe.DataFrame.to_arrow

to_arrow(
    *, ordered: bool = True, allow_large_results: typing.Optional[bool] = None
) -> pyarrow.lib.Table

Write DataFrame to an Arrow table / record batch.

See more: bigframes.dataframe.DataFrame.to_arrow

bigframes.dataframe.DataFrame.to_csv

to_csv(
    path_or_buf=None,
    sep=",",
    *,
    header: bool = True,
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[str]

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

See more: bigframes.dataframe.DataFrame.to_csv

bigframes.dataframe.DataFrame.to_dict

to_dict(
    orient: typing.Literal[
        "dict", "list", "series", "split", "tight", "records", "index"
    ] = "dict",
    into: type[dict] = dict,
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> dict | list[dict]

Convert the DataFrame to a dictionary.

See more: bigframes.dataframe.DataFrame.to_dict

bigframes.dataframe.DataFrame.to_excel

to_excel(
    excel_writer,
    sheet_name: str = "Sheet1",
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> None

Write DataFrame to an Excel sheet.

See more: bigframes.dataframe.DataFrame.to_excel

bigframes.dataframe.DataFrame.to_gbq

to_gbq(
    destination_table: typing.Optional[str] = None,
    *,
    if_exists: typing.Optional[typing.Literal["fail", "replace", "append"]] = None,
    index: bool = True,
    ordering_id: typing.Optional[str] = None,
    clustering_columns: typing.Union[
        pandas.core.indexes.base.Index, typing.Iterable[typing.Hashable]
    ] = (),
    labels: dict[str, str] = {}
) -> str

Write a DataFrame to a BigQuery table.

See more: bigframes.dataframe.DataFrame.to_gbq

bigframes.dataframe.DataFrame.to_html

to_html(
    buf=None,
    columns: typing.Optional[typing.Sequence[str]] = None,
    col_space=None,
    header: bool = 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 = ".",
    bold_rows: bool = True,
    classes: str | list | tuple | None = None,
    escape: bool = True,
    notebook: bool = False,
    border: int | None = None,
    table_id: str | None = None,
    render_links: bool = False,
    encoding: str | None = None,
    *,
    allow_large_results: bool | None = None
) -> str

Render a DataFrame as an HTML table.

See more: bigframes.dataframe.DataFrame.to_html

bigframes.dataframe.DataFrame.to_json

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

Convert the object to a JSON string, written to Cloud Storage.

See more: bigframes.dataframe.DataFrame.to_json

bigframes.dataframe.DataFrame.to_latex

to_latex(
    buf=None,
    columns: typing.Optional[typing.Sequence] = None,
    header: typing.Union[bool, typing.Sequence[str]] = True,
    index: bool = True,
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> str | None

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

See more: bigframes.dataframe.DataFrame.to_latex

bigframes.dataframe.DataFrame.to_markdown

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

Print DataFrame in Markdown-friendly format.

See more: bigframes.dataframe.DataFrame.to_markdown

bigframes.dataframe.DataFrame.to_numpy

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

Convert the DataFrame to a NumPy array.

See more: bigframes.dataframe.DataFrame.to_numpy

bigframes.dataframe.DataFrame.to_orc

to_orc(path=None, *, allow_large_results=None, **kwargs) -> bytes | None

Write a DataFrame to the ORC format.

See more: bigframes.dataframe.DataFrame.to_orc

bigframes.dataframe.DataFrame.to_pandas

Write DataFrame to pandas DataFrame.

See more: bigframes.dataframe.DataFrame.to_pandas

bigframes.dataframe.DataFrame.to_pandas_batches

to_pandas_batches(
    page_size: typing.Optional[int] = None,
    max_results: typing.Optional[int] = None,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Iterable[pandas.core.frame.DataFrame]

Stream DataFrame results to an iterable of pandas DataFrame.

See more: bigframes.dataframe.DataFrame.to_pandas_batches

bigframes.dataframe.DataFrame.to_parquet

to_parquet(
    path=None,
    *,
    compression: typing.Optional[typing.Literal["snappy", "gzip"]] = "snappy",
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[bytes]

Write a DataFrame to the binary Parquet format.

See more: bigframes.dataframe.DataFrame.to_parquet

bigframes.dataframe.DataFrame.to_pickle

to_pickle(path, *, allow_large_results=None, **kwargs) -> None

Pickle (serialize) object to file.

See more: bigframes.dataframe.DataFrame.to_pickle

bigframes.dataframe.DataFrame.to_records

to_records(
    index: bool = True,
    column_dtypes=None,
    index_dtypes=None,
    *,
    allow_large_results=None
) -> numpy.rec.recarray

Convert DataFrame to a NumPy record array.

See more: bigframes.dataframe.DataFrame.to_records

bigframes.dataframe.DataFrame.to_string

to_string(
    buf=None,
    columns: typing.Optional[typing.Sequence[str]] = None,
    col_space=None,
    header: typing.Union[bool, typing.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,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> str | None

Render a DataFrame to a console-friendly tabular output.

See more: bigframes.dataframe.DataFrame.to_string

bigframes.dataframe.DataFrame.transpose

transpose() -> bigframes.dataframe.DataFrame

Transpose index and columns.

See more: bigframes.dataframe.DataFrame.transpose

bigframes.dataframe.DataFrame.truediv

truediv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.dataframe.DataFrame.truediv

bigframes.dataframe.DataFrame.unstack

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

Pivot a level of the (necessarily hierarchical) index labels.

See more: bigframes.dataframe.DataFrame.unstack

bigframes.dataframe.DataFrame.update

update(other, join: str = "left", overwrite=True, filter_func=None)

Modify in place using non-NA values from another DataFrame.

See more: bigframes.dataframe.DataFrame.update

bigframes.dataframe.DataFrame.value_counts

value_counts(
    subset: 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.

See more: bigframes.dataframe.DataFrame.value_counts

bigframes.dataframe.DataFrame.var

var(
    axis: typing.Union[str, int] = 0, *, numeric_only: bool = False
) -> bigframes.series.Series

Return unbiased variance over requested axis.

See more: bigframes.dataframe.DataFrame.var

bigframes.dataframe.DataFrame.where

where(cond, other=None)

Replace values where the condition is False.

See more: bigframes.dataframe.DataFrame.where

bigframes.geopandas.GeoSeries.abs

__abs__() -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.abs

bigframes.geopandas.GeoSeries.add

__add__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.geopandas.GeoSeries.add

bigframes.geopandas.GeoSeries.and

__and__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.geopandas.GeoSeries.and

bigframes.geopandas.GeoSeries.array

__array__(dtype=None, copy: typing.Optional[bool] = None) -> numpy.ndarray

Returns the values as NumPy array.

See more: bigframes.geopandas.GeoSeries.array

bigframes.geopandas.GeoSeries.__array_ufunc__

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

Used to support numpy ufuncs.

See more: bigframes.geopandas.GeoSeries.array_ufunc

bigframes.geopandas.GeoSeries.bool

__bool__()

Returns the truth value of the object.

See more: bigframes.geopandas.GeoSeries.bool

bigframes.geopandas.GeoSeries.floordiv

__floordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of Series by other, using arithmetic operator //.

See more: bigframes.geopandas.GeoSeries.floordiv

bigframes.geopandas.GeoSeries.getitem

__getitem__(indexer)

Gets the specified index from the Series.

See more: bigframes.geopandas.GeoSeries.getitem

bigframes.geopandas.GeoSeries.invert

__invert__() -> bigframes.series.Series

Returns the logical inversion (binary NOT) of the Series, element-wise using operator ````.

See more: bigframes.geopandas.GeoSeries.invert

bigframes.geopandas.GeoSeries.len

__len__()

Returns number of values in the Series, serves len operator.

See more: bigframes.geopandas.GeoSeries.len

bigframes.geopandas.GeoSeries.matmul

__matmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.geopandas.GeoSeries.matmul

bigframes.geopandas.GeoSeries.mod

__mod__(other) -> bigframes.series.Series

Get modulo of Series with other, element-wise, using operator %.

See more: bigframes.geopandas.GeoSeries.mod

bigframes.geopandas.GeoSeries.mul

__mul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of Series with other, element-wise, using operator *.

See more: bigframes.geopandas.GeoSeries.mul

bigframes.geopandas.GeoSeries.nonzero

__nonzero__()

Returns the truth value of the object.

See more: bigframes.geopandas.GeoSeries.nonzero

bigframes.geopandas.GeoSeries.or

__or__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.geopandas.GeoSeries.or

bigframes.geopandas.GeoSeries.pow

__pow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of Series with other, element-wise, using operator **.

See more: bigframes.geopandas.GeoSeries.pow

bigframes.geopandas.GeoSeries.radd

__radd__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.geopandas.GeoSeries.radd

bigframes.geopandas.GeoSeries.rand

__rand__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.geopandas.GeoSeries.rand

bigframes.geopandas.GeoSeries.rfloordiv

__rfloordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of other by Series, using arithmetic operator //.

See more: bigframes.geopandas.GeoSeries.rfloordiv

bigframes.geopandas.GeoSeries.rmatmul

__rmatmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.geopandas.GeoSeries.rmatmul

bigframes.geopandas.GeoSeries.rmod

__rmod__(other) -> bigframes.series.Series

Get modulo of other with Series, element-wise, using operator %.

See more: bigframes.geopandas.GeoSeries.rmod

bigframes.geopandas.GeoSeries.rmul

__rmul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of other with Series, element-wise, using operator *.

See more: bigframes.geopandas.GeoSeries.rmul

bigframes.geopandas.GeoSeries.ror

__ror__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.geopandas.GeoSeries.ror

bigframes.geopandas.GeoSeries.rpow

__rpow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of other with Series, element-wise, using operator **.

See more: bigframes.geopandas.GeoSeries.rpow

bigframes.geopandas.GeoSeries.rsub

__rsub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of Series from other, element-wise, using operator -.

See more: bigframes.geopandas.GeoSeries.rsub

bigframes.geopandas.GeoSeries.rtruediv

__rtruediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of other by Series, element-wise, using operator /.

See more: bigframes.geopandas.GeoSeries.rtruediv

bigframes.geopandas.GeoSeries.setitem

__setitem__(key, value) -> None

Set item using direct assignment, delegating to .loc indexer.

See more: bigframes.geopandas.GeoSeries.setitem

bigframes.geopandas.GeoSeries.sub

__sub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of other from Series, element-wise, using operator -.

See more: bigframes.geopandas.GeoSeries.sub

bigframes.geopandas.GeoSeries.truediv

__truediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of Series by other, element-wise, using operator /.

See more: bigframes.geopandas.GeoSeries.truediv

bigframes.geopandas.GeoSeries.abs

abs() -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.abs

bigframes.geopandas.GeoSeries.add

add(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.add

bigframes.geopandas.GeoSeries.add_prefix

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

Prefix labels with string prefix.

See more: bigframes.geopandas.GeoSeries.add_prefix

bigframes.geopandas.GeoSeries.add_suffix

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

Suffix labels with string suffix.

See more: bigframes.geopandas.GeoSeries.add_suffix

bigframes.geopandas.GeoSeries.agg

agg(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.geopandas.GeoSeries.agg

bigframes.geopandas.GeoSeries.aggregate

aggregate(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.geopandas.GeoSeries.aggregate

bigframes.geopandas.GeoSeries.all

all() -> bool

Return whether all elements are True, potentially over an axis.

See more: bigframes.geopandas.GeoSeries.all

bigframes.geopandas.GeoSeries.any

any() -> bool

Return whether any element is True, potentially over an axis.

See more: bigframes.geopandas.GeoSeries.any

bigframes.geopandas.GeoSeries.apply

apply(
    func,
    by_row: typing.Union[typing.Literal["compat"], bool] = "compat",
    *,
    args: typing.Tuple = ()
) -> bigframes.series.Series

Invoke function on values of a Series.

See more: bigframes.geopandas.GeoSeries.apply

bigframes.geopandas.GeoSeries.argmax

argmax() -> int

Return int position of the largest value in the series.

See more: bigframes.geopandas.GeoSeries.argmax

bigframes.geopandas.GeoSeries.argmin

argmin() -> int

Return int position of the smallest value in the Series.

See more: bigframes.geopandas.GeoSeries.argmin

bigframes.geopandas.GeoSeries.astype

astype(
    dtype: typing.Union[
        typing.Literal[
            "boolean",
            "Float64",
            "Int64",
            "int64[pyarrow]",
            "string",
            "string[pyarrow]",
            "timestamp[us, tz=UTC][pyarrow]",
            "timestamp[us][pyarrow]",
            "date32[day][pyarrow]",
            "time64[us][pyarrow]",
            "decimal128(38, 9)[pyarrow]",
            "decimal256(76, 38)[pyarrow]",
            "binary[pyarrow]",
            "duration[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,
        geopandas.array.GeometryDtype,
    ],
    *,
    errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.series.Series

Cast a pandas object to a specified dtype dtype.

See more: bigframes.geopandas.GeoSeries.astype

bigframes.geopandas.GeoSeries.autocorr

autocorr(lag: int = 1) -> float

Compute the lag-N autocorrelation.

See more: bigframes.geopandas.GeoSeries.autocorr

bigframes.geopandas.GeoSeries.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.geopandas.GeoSeries.bar

bigframes.geopandas.GeoSeries.between

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

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

See more: bigframes.geopandas.GeoSeries.between

bigframes.geopandas.GeoSeries.bfill

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

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

See more: bigframes.geopandas.GeoSeries.bfill

bigframes.geopandas.GeoSeries.buffer

buffer(distance: float) -> bigframes.series.Series

API documentation for buffer method.

See more: bigframes.geopandas.GeoSeries.buffer

bigframes.geopandas.GeoSeries.cache

cache()

Materializes the Series to a temporary table.

See more: bigframes.geopandas.GeoSeries.cache

bigframes.geopandas.GeoSeries.case_when

case_when(caselist) -> bigframes.series.Series

Replace values where the conditions are True.

See more: bigframes.geopandas.GeoSeries.case_when

bigframes.geopandas.GeoSeries.clip

clip(lower=None, upper=None)

Trim values at input threshold(s).

See more: bigframes.geopandas.GeoSeries.clip

bigframes.geopandas.GeoSeries.combine

combine(other, func) -> bigframes.series.Series

Combine the Series with a Series or scalar according to func.

See more: bigframes.geopandas.GeoSeries.combine

bigframes.geopandas.GeoSeries.combine_first

combine_first(other: bigframes.series.Series) -> bigframes.series.Series

Update null elements with value in the same location in 'other'.

See more: bigframes.geopandas.GeoSeries.combine_first

bigframes.geopandas.GeoSeries.copy

copy() -> bigframes.series.Series

Make a copy of this object's indices and data.

See more: bigframes.geopandas.GeoSeries.copy

bigframes.geopandas.GeoSeries.corr

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

Compute the correlation with the other Series.

See more: bigframes.geopandas.GeoSeries.corr

bigframes.geopandas.GeoSeries.count

count() -> int

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

See more: bigframes.geopandas.GeoSeries.count

bigframes.geopandas.GeoSeries.cov

cov(other: bigframes.series.Series) -> float

Compute covariance with Series, excluding missing values.

See more: bigframes.geopandas.GeoSeries.cov

bigframes.geopandas.GeoSeries.cummax

cummax() -> bigframes.series.Series

Return cumulative maximum over a DataFrame or Series axis.

See more: bigframes.geopandas.GeoSeries.cummax

bigframes.geopandas.GeoSeries.cummin

cummin() -> bigframes.series.Series

Return cumulative minimum over a DataFrame or Series axis.

See more: bigframes.geopandas.GeoSeries.cummin

bigframes.geopandas.GeoSeries.cumprod

cumprod() -> bigframes.series.Series

Return cumulative product over a DataFrame or Series axis.

See more: bigframes.geopandas.GeoSeries.cumprod

bigframes.geopandas.GeoSeries.cumsum

cumsum() -> bigframes.series.Series

Return cumulative sum over a DataFrame or Series axis.

See more: bigframes.geopandas.GeoSeries.cumsum

bigframes.geopandas.GeoSeries.describe

describe() -> bigframes.series.Series

Generate descriptive statistics.

See more: bigframes.geopandas.GeoSeries.describe

bigframes.geopandas.GeoSeries.diff

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

First discrete difference of element.

See more: bigframes.geopandas.GeoSeries.diff

bigframes.geopandas.GeoSeries.difference

difference(
    other: bigframes.geopandas.geoseries.GeoSeries,
) -> bigframes.series.Series

Returns a GeoSeries of the points in each aligned geometry that are not in other.

See more: bigframes.geopandas.GeoSeries.difference

bigframes.geopandas.GeoSeries.distance

distance(other: bigframes.geopandas.geoseries.GeoSeries) -> bigframes.series.Series

[Not Implemented] Use <xref uid="bigframes.bigquery.st_distance">bigframes.bigquery.st_distance</xref>(series, other) instead to return the shorted distance between two GEOGRAPHY objects in meters.

See more: bigframes.geopandas.GeoSeries.distance

bigframes.geopandas.GeoSeries.div

div(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.div

bigframes.geopandas.GeoSeries.divide

divide(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.divide

bigframes.geopandas.GeoSeries.divmod

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

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

See more: bigframes.geopandas.GeoSeries.divmod

bigframes.geopandas.GeoSeries.dot

dot(other)

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

See more: bigframes.geopandas.GeoSeries.dot

bigframes.geopandas.GeoSeries.drop

drop(
    labels: typing.Any = None,
    *,
    axis: typing.Union[int, str] = 0,
    index: typing.Any = None,
    columns: 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.

See more: bigframes.geopandas.GeoSeries.drop

bigframes.geopandas.GeoSeries.drop_duplicates

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

Return Series with duplicate values removed.

See more: bigframes.geopandas.GeoSeries.drop_duplicates

bigframes.geopandas.GeoSeries.droplevel

droplevel(
    level: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

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

See more: bigframes.geopandas.GeoSeries.droplevel

bigframes.geopandas.GeoSeries.dropna

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.

See more: bigframes.geopandas.GeoSeries.dropna

bigframes.geopandas.GeoSeries.duplicated

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

Indicate duplicate Series values.

See more: bigframes.geopandas.GeoSeries.duplicated

bigframes.geopandas.GeoSeries.eq

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

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

See more: bigframes.geopandas.GeoSeries.eq

bigframes.geopandas.GeoSeries.equals

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

Test whether two objects contain the same elements.

See more: bigframes.geopandas.GeoSeries.equals

bigframes.geopandas.GeoSeries.expanding

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

Provide expanding window calculations.

See more: bigframes.geopandas.GeoSeries.expanding

bigframes.geopandas.GeoSeries.explode

explode(*, ignore_index: typing.Optional[bool] = False) -> bigframes.series.Series

Transform each element of a list-like to a row.

See more: bigframes.geopandas.GeoSeries.explode

bigframes.geopandas.GeoSeries.ffill

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

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

See more: bigframes.geopandas.GeoSeries.ffill

bigframes.geopandas.GeoSeries.fillna

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

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.geopandas.GeoSeries.fillna

bigframes.geopandas.GeoSeries.filter

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.

See more: bigframes.geopandas.GeoSeries.filter

bigframes.geopandas.GeoSeries.floordiv

floordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.floordiv

bigframes.geopandas.GeoSeries.from_wkt

from_wkt(
    data, index=None, *, session: typing.Optional[bigframes.session.Session] = None
) -> bigframes.geopandas.geoseries.GeoSeries

Alternate constructor to create a GeoSeries from a list or array of WKT objects.

See more: bigframes.geopandas.GeoSeries.from_wkt

bigframes.geopandas.GeoSeries.from_xy

from_xy(
    x, y, index=None, session=None, **kwargs
) -> bigframes.geopandas.geoseries.GeoSeries

Alternate constructor to create a GeoSeries of Point geometries from lists or arrays of x, y coordinates.

See more: bigframes.geopandas.GeoSeries.from_xy

bigframes.geopandas.GeoSeries.ge

ge(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.ge

bigframes.geopandas.GeoSeries.get

get(key, default=None)

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

See more: bigframes.geopandas.GeoSeries.get

bigframes.geopandas.GeoSeries.groupby

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

Group Series using a mapper or by a Series of columns.

See more: bigframes.geopandas.GeoSeries.groupby

bigframes.geopandas.GeoSeries.gt

gt(other) -> bigframes.series.Series

Return Greater than of series and other, element-wise (binary operator gt).

See more: bigframes.geopandas.GeoSeries.gt

bigframes.geopandas.GeoSeries.head

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

Return the first n rows.

See more: bigframes.geopandas.GeoSeries.head

bigframes.geopandas.GeoSeries.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.geopandas.GeoSeries.hist

bigframes.geopandas.GeoSeries.idxmax

idxmax() -> typing.Hashable

Return the row label of the maximum value.

See more: bigframes.geopandas.GeoSeries.idxmax

bigframes.geopandas.GeoSeries.idxmin

idxmin() -> typing.Hashable

Return the row label of the minimum value.

See more: bigframes.geopandas.GeoSeries.idxmin

bigframes.geopandas.GeoSeries.interpolate

interpolate(method: str = "linear") -> bigframes.series.Series

Fill NaN values using an interpolation method.

See more: bigframes.geopandas.GeoSeries.interpolate

bigframes.geopandas.GeoSeries.intersection

intersection(
    other: bigframes.geopandas.geoseries.GeoSeries,
) -> bigframes.series.Series

Returns a GeoSeries of the intersection of points in each aligned geometry with other.

See more: bigframes.geopandas.GeoSeries.intersection

bigframes.geopandas.GeoSeries.isin

isin(values) -> bigframes.series.Series

Whether elements in Series are contained in values.

See more: bigframes.geopandas.GeoSeries.isin

bigframes.geopandas.GeoSeries.isna

isna() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.geopandas.GeoSeries.isna

bigframes.geopandas.GeoSeries.isnull

isnull() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.geopandas.GeoSeries.isnull

bigframes.geopandas.GeoSeries.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.geopandas.GeoSeries.item

bigframes.geopandas.GeoSeries.items

items()

Lazily iterate over (index, value) tuples.

See more: bigframes.geopandas.GeoSeries.items

bigframes.geopandas.GeoSeries.keys

keys() -> bigframes.core.indexes.base.Index

Return alias for index.

See more: bigframes.geopandas.GeoSeries.keys

bigframes.geopandas.GeoSeries.kurt

kurt()

Return unbiased kurtosis over requested axis.

See more: bigframes.geopandas.GeoSeries.kurt

bigframes.geopandas.GeoSeries.kurtosis

kurtosis()

Return unbiased kurtosis over requested axis.

See more: bigframes.geopandas.GeoSeries.kurtosis

bigframes.geopandas.GeoSeries.le

le(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.le

bigframes.geopandas.GeoSeries.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.geopandas.GeoSeries.line

bigframes.geopandas.GeoSeries.lt

lt(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.lt

bigframes.geopandas.GeoSeries.map

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

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

See more: bigframes.geopandas.GeoSeries.map

bigframes.geopandas.GeoSeries.mask

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

Replace values where the condition is True.

See more: bigframes.geopandas.GeoSeries.mask

bigframes.geopandas.GeoSeries.max

max() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.max

bigframes.geopandas.GeoSeries.mean

mean() -> float

Return the mean of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.mean

bigframes.geopandas.GeoSeries.median

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

Return the median of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.median

bigframes.geopandas.GeoSeries.min

min() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.min

bigframes.geopandas.GeoSeries.mod

mod(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.mod

bigframes.geopandas.GeoSeries.mode

mode() -> bigframes.series.Series

Return the mode(s) of the Series.

See more: bigframes.geopandas.GeoSeries.mode

bigframes.geopandas.GeoSeries.mul

mul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.mul

bigframes.geopandas.GeoSeries.multiply

multiply(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.multiply

bigframes.geopandas.GeoSeries.ne

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

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

See more: bigframes.geopandas.GeoSeries.ne

bigframes.geopandas.GeoSeries.nlargest

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

Return the largest n elements.

See more: bigframes.geopandas.GeoSeries.nlargest

bigframes.geopandas.GeoSeries.notna

notna() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.geopandas.GeoSeries.notna

bigframes.geopandas.GeoSeries.notnull

notnull() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.geopandas.GeoSeries.notnull

bigframes.geopandas.GeoSeries.nsmallest

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

Return the smallest n elements.

See more: bigframes.geopandas.GeoSeries.nsmallest

bigframes.geopandas.GeoSeries.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.geopandas.GeoSeries.nunique

bigframes.geopandas.GeoSeries.pad

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

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

See more: bigframes.geopandas.GeoSeries.pad

bigframes.geopandas.GeoSeries.pct_change

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

Fractional change between the current and a prior element.

See more: bigframes.geopandas.GeoSeries.pct_change

bigframes.geopandas.GeoSeries.peek

peek(
    n: int = 5, *, force: bool = True, allow_large_results=None
) -> pandas.core.series.Series

Preview n arbitrary elements from the series without guarantees about row selection or ordering.

See more: bigframes.geopandas.GeoSeries.peek

bigframes.geopandas.GeoSeries.pipe

pipe(func: Callable[..., T] | tuple[Callable[..., T], str], *args, **kwargs) -> T

Apply chainable functions that expect Series or DataFrames.

See more: bigframes.geopandas.GeoSeries.pipe

bigframes.geopandas.GeoSeries.pow

pow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.pow

bigframes.geopandas.GeoSeries.prod

prod() -> float

Return the product of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.prod

bigframes.geopandas.GeoSeries.product

product() -> float

Return the product of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.product

bigframes.geopandas.GeoSeries.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5,
) -> typing.Union[bigframes.series.Series, float]

Return value at the given quantile.

See more: bigframes.geopandas.GeoSeries.quantile

bigframes.geopandas.GeoSeries.radd

radd(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.radd

bigframes.geopandas.GeoSeries.rank

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

Compute numerical data ranks (1 through n) along axis.

See more: bigframes.geopandas.GeoSeries.rank

bigframes.geopandas.GeoSeries.rdiv

rdiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rdiv

bigframes.geopandas.GeoSeries.rdivmod

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

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

See more: bigframes.geopandas.GeoSeries.rdivmod

bigframes.geopandas.GeoSeries.reindex

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

Conform Series to new index with optional filling logic.

See more: bigframes.geopandas.GeoSeries.reindex

bigframes.geopandas.GeoSeries.reindex_like

reindex_like(
    other: bigframes.series.Series, *, validate: typing.Optional[bool] = None
)

Return an object with matching indices as other object.

See more: bigframes.geopandas.GeoSeries.reindex_like

bigframes.geopandas.GeoSeries.rename

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

Alter Series index labels or name.

See more: bigframes.geopandas.GeoSeries.rename

bigframes.geopandas.GeoSeries.rename_axis

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

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

See more: bigframes.geopandas.GeoSeries.rename_axis

bigframes.geopandas.GeoSeries.reorder_levels

reorder_levels(
    order: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

Rearrange index levels using input order.

See more: bigframes.geopandas.GeoSeries.reorder_levels

bigframes.geopandas.GeoSeries.replace

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

Replace values given in to_replace with value.

See more: bigframes.geopandas.GeoSeries.replace

bigframes.geopandas.GeoSeries.resample

resample(
    rule: str,
    *,
    closed: typing.Optional[typing.Literal["right", "left"]] = None,
    label: typing.Optional[typing.Literal["right", "left"]] = None,
    level: typing.Optional[
        typing.Union[str, int, typing.Sequence[typing.Union[str, int]]]
    ] = None,
    origin: typing.Union[
        pandas._libs.tslibs.timestamps.Timestamp,
        datetime.datetime,
        numpy.datetime64,
        int,
        float,
        str,
        typing.Literal["epoch", "start", "start_day", "end", "end_day"],
    ] = "start_day"
) -> bigframes.core.groupby.series_group_by.SeriesGroupBy

Resample time-series data.

See more: bigframes.geopandas.GeoSeries.resample

bigframes.geopandas.GeoSeries.reset_index

reset_index(
    level: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    *,
    name: typing.Optional[str] = None,
    drop: bool = False,
    inplace: bool = False,
    allow_duplicates: typing.Optional[bool] = None
) -> bigframes.dataframe.DataFrame | bigframes.series.Series | None

Generate a new DataFrame or Series with the index reset.

See more: bigframes.geopandas.GeoSeries.reset_index

bigframes.geopandas.GeoSeries.rfloordiv

rfloordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rfloordiv

bigframes.geopandas.GeoSeries.rmod

rmod(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rmod

bigframes.geopandas.GeoSeries.rmul

rmul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rmul

bigframes.geopandas.GeoSeries.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods: int | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Provide rolling window calculations.

See more: bigframes.geopandas.GeoSeries.rolling

bigframes.geopandas.GeoSeries.round

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

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

See more: bigframes.geopandas.GeoSeries.round

bigframes.geopandas.GeoSeries.rpow

rpow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rpow

bigframes.geopandas.GeoSeries.rsub

rsub(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rsub

bigframes.geopandas.GeoSeries.rtruediv

rtruediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.rtruediv

bigframes.geopandas.GeoSeries.sample

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None,
    sort: typing.Optional[typing.Union[bool, typing.Literal["random"]]] = "random"
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.sample

bigframes.geopandas.GeoSeries.shift

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

Shift index by desired number of periods.

See more: bigframes.geopandas.GeoSeries.shift

bigframes.geopandas.GeoSeries.simplify

simplify(tolerance, preserve_topology=True)

[Not Implemented] Use <xref uid="bigframes.bigquery.st_simplify">bigframes.bigquery.st_simplify</xref>(series, tolerance_meters), instead to set the tolerance in meters.

See more: bigframes.geopandas.GeoSeries.simplify

bigframes.geopandas.GeoSeries.skew

skew()

Return unbiased skew over requested axis.

See more: bigframes.geopandas.GeoSeries.skew

bigframes.geopandas.GeoSeries.sort_index

sort_index(
    *, axis=0, inplace: bool = False, ascending=True, na_position="last"
) -> typing.Optional[bigframes.series.Series]

Sort Series by index labels.

See more: bigframes.geopandas.GeoSeries.sort_index

bigframes.geopandas.GeoSeries.sort_values

sort_values(
    *,
    axis=0,
    inplace: bool = False,
    ascending=True,
    kind: str = "quicksort",
    na_position: typing.Literal["first", "last"] = "last"
) -> typing.Optional[bigframes.series.Series]

Sort by the values.

See more: bigframes.geopandas.GeoSeries.sort_values

bigframes.geopandas.GeoSeries.std

std() -> float

Return sample standard deviation over requested axis.

See more: bigframes.geopandas.GeoSeries.std

bigframes.geopandas.GeoSeries.sub

sub(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.sub

bigframes.geopandas.GeoSeries.subtract

subtract(other) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.subtract

bigframes.geopandas.GeoSeries.sum

sum() -> float

Return the sum of the values over the requested axis.

See more: bigframes.geopandas.GeoSeries.sum

bigframes.geopandas.GeoSeries.swaplevel

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

Swap levels i and j in a MultiIndex.

See more: bigframes.geopandas.GeoSeries.swaplevel

bigframes.geopandas.GeoSeries.tail

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

Return the last n rows.

See more: bigframes.geopandas.GeoSeries.tail

bigframes.geopandas.GeoSeries.take

take(
    indices: typing.Sequence[int], axis: int | str | None = 0, **kwargs
) -> bigframes.series.Series

Return the elements in the given positional indices along an axis.

See more: bigframes.geopandas.GeoSeries.take

bigframes.geopandas.GeoSeries.to_csv

to_csv(
    path_or_buf=None,
    sep=",",
    *,
    header: bool = True,
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[str]

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

See more: bigframes.geopandas.GeoSeries.to_csv

bigframes.geopandas.GeoSeries.to_dict

to_dict(
    into: type[dict] = dict, *, allow_large_results: typing.Optional[bool] = None
) -> typing.Mapping

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

See more: bigframes.geopandas.GeoSeries.to_dict

bigframes.geopandas.GeoSeries.to_excel

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

Write Series to an Excel sheet.

See more: bigframes.geopandas.GeoSeries.to_excel

bigframes.geopandas.GeoSeries.to_frame

to_frame(name: typing.Hashable = None) -> bigframes.dataframe.DataFrame

Convert Series to DataFrame.

See more: bigframes.geopandas.GeoSeries.to_frame

bigframes.geopandas.GeoSeries.to_json

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

Convert the object to a JSON string, written to Cloud Storage.

See more: bigframes.geopandas.GeoSeries.to_json

bigframes.geopandas.GeoSeries.to_latex

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

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

See more: bigframes.geopandas.GeoSeries.to_latex

bigframes.geopandas.GeoSeries.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.geopandas.GeoSeries.to_list

bigframes.geopandas.GeoSeries.to_markdown

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

Print Series in Markdown-friendly format.

See more: bigframes.geopandas.GeoSeries.to_markdown

bigframes.geopandas.GeoSeries.to_numpy

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

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

See more: bigframes.geopandas.GeoSeries.to_numpy

bigframes.geopandas.GeoSeries.to_pandas

to_pandas(
    max_download_size: typing.Optional[int] = None,
    sampling_method: typing.Optional[str] = None,
    random_state: typing.Optional[int] = None,
    *,
    ordered: bool = True,
    dry_run: bool = False,
    allow_large_results: typing.Optional[bool] = None
) -> pandas.core.series.Series

Writes Series to pandas Series.

See more: bigframes.geopandas.GeoSeries.to_pandas

bigframes.geopandas.GeoSeries.to_pandas_batches

to_pandas_batches(
    page_size: typing.Optional[int] = None,
    max_results: typing.Optional[int] = None,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Iterable[pandas.core.series.Series]

Stream Series results to an iterable of pandas Series.

See more: bigframes.geopandas.GeoSeries.to_pandas_batches

bigframes.geopandas.GeoSeries.to_pickle

to_pickle(path, *, allow_large_results=None, **kwargs) -> None

Pickle (serialize) object to file.

See more: bigframes.geopandas.GeoSeries.to_pickle

bigframes.geopandas.GeoSeries.to_string

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,
    *,
    allow_large_results=None
) -> typing.Optional[str]

Render a string representation of the Series.

See more: bigframes.geopandas.GeoSeries.to_string

bigframes.geopandas.GeoSeries.to_wkt

to_wkt() -> bigframes.series.Series

Convert GeoSeries geometries to WKT.

See more: bigframes.geopandas.GeoSeries.to_wkt

bigframes.geopandas.GeoSeries.to_xarray

to_xarray(*, allow_large_results: typing.Optional[bool] = None)

Return an xarray object from the pandas object.

See more: bigframes.geopandas.GeoSeries.to_xarray

bigframes.geopandas.GeoSeries.tolist

tolist(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.geopandas.GeoSeries.tolist

bigframes.geopandas.GeoSeries.transpose

transpose() -> bigframes.series.Series

Return the transpose, which is by definition self.

See more: bigframes.geopandas.GeoSeries.transpose

bigframes.geopandas.GeoSeries.truediv

truediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.geopandas.GeoSeries.truediv

bigframes.geopandas.GeoSeries.unique

unique(keep_order=True) -> bigframes.series.Series

Return unique values of Series object.

See more: bigframes.geopandas.GeoSeries.unique

bigframes.geopandas.GeoSeries.unstack

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

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

See more: bigframes.geopandas.GeoSeries.unstack

bigframes.geopandas.GeoSeries.update

update(
    other: typing.Union[bigframes.series.Series, typing.Sequence, typing.Mapping],
) -> None

Modify Series in place using values from passed Series.

See more: bigframes.geopandas.GeoSeries.update

bigframes.geopandas.GeoSeries.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.geopandas.GeoSeries.value_counts

bigframes.geopandas.GeoSeries.var

var() -> float

Return unbiased variance over requested axis.

See more: bigframes.geopandas.GeoSeries.var

bigframes.geopandas.GeoSeries.where

where(cond, other=None)

Replace values where the condition is False.

See more: bigframes.geopandas.GeoSeries.where

bigframes.ml.cluster.KMeans.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.cluster.KMeans.repr

bigframes.ml.cluster.KMeans.detect_anomalies

detect_anomalies(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    contamination: float = 0.1
) -> bigframes.dataframe.DataFrame

Detect the anomaly data points of the input.

See more: bigframes.ml.cluster.KMeans.detect_anomalies

bigframes.ml.cluster.KMeans.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Compute k-means clustering.

See more: bigframes.ml.cluster.KMeans.fit

bigframes.ml.cluster.KMeans.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.cluster.KMeans.get_params

bigframes.ml.cluster.KMeans.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the closest cluster each sample in X belongs to.

See more: bigframes.ml.cluster.KMeans.predict

bigframes.ml.cluster.KMeans.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.cluster.KMeans.register

bigframes.ml.cluster.KMeans.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.cluster.KMeans.score

bigframes.ml.cluster.KMeans.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.cluster.KMeans

Save the model to BigQuery.

See more: bigframes.ml.cluster.KMeans.to_gbq

bigframes.ml.compose.ColumnTransformer.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.compose.ColumnTransformer.repr

bigframes.ml.compose.ColumnTransformer.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.compose.ColumnTransformer

Fit all transformers using X.

See more: bigframes.ml.compose.ColumnTransformer.fit

bigframes.ml.compose.ColumnTransformer.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

API documentation for fit_transform method.

See more: bigframes.ml.compose.ColumnTransformer.fit_transform

bigframes.ml.compose.ColumnTransformer.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.compose.ColumnTransformer.get_params

bigframes.ml.compose.ColumnTransformer.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.compose.ColumnTransformer.to_gbq

bigframes.ml.compose.ColumnTransformer.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Transform X separately by each transformer, concatenate results.

See more: bigframes.ml.compose.ColumnTransformer.transform

bigframes.ml.decomposition.MatrixFactorization.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.decomposition.MatrixFactorization.repr

bigframes.ml.decomposition.MatrixFactorization.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit the model according to the given training data.

See more: bigframes.ml.decomposition.MatrixFactorization.fit

bigframes.ml.decomposition.MatrixFactorization.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.decomposition.MatrixFactorization.get_params

bigframes.ml.decomposition.MatrixFactorization.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Generate a predicted rating for every user-item row combination for a matrix factorization model.

See more: bigframes.ml.decomposition.MatrixFactorization.predict

bigframes.ml.decomposition.MatrixFactorization.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.decomposition.MatrixFactorization.register

bigframes.ml.decomposition.MatrixFactorization.score

score(X=None, y=None) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.decomposition.MatrixFactorization.score

bigframes.ml.decomposition.MatrixFactorization.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.decomposition.MatrixFactorization

Save the model to BigQuery.

See more: bigframes.ml.decomposition.MatrixFactorization.to_gbq

bigframes.ml.decomposition.PCA.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.decomposition.PCA.repr

bigframes.ml.decomposition.PCA.detect_anomalies

detect_anomalies(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    contamination: float = 0.1
) -> bigframes.dataframe.DataFrame

Detect the anomaly data points of the input.

See more: bigframes.ml.decomposition.PCA.detect_anomalies

bigframes.ml.decomposition.PCA.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit the model according to the given training data.

See more: bigframes.ml.decomposition.PCA.fit

bigframes.ml.decomposition.PCA.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.decomposition.PCA.get_params

bigframes.ml.decomposition.PCA.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the closest cluster for each sample in X.

See more: bigframes.ml.decomposition.PCA.predict

bigframes.ml.decomposition.PCA.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.decomposition.PCA.register

bigframes.ml.decomposition.PCA.score

score(X=None, y=None) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.decomposition.PCA.score

bigframes.ml.decomposition.PCA.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.decomposition.PCA

Save the model to BigQuery.

See more: bigframes.ml.decomposition.PCA.to_gbq

bigframes.ml.ensemble.RandomForestClassifier.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.ensemble.RandomForestClassifier.repr

bigframes.ml.ensemble.RandomForestClassifier.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Build a forest of trees from the training set (X, y).

See more: bigframes.ml.ensemble.RandomForestClassifier.fit

bigframes.ml.ensemble.RandomForestClassifier.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.ensemble.RandomForestClassifier.get_params

bigframes.ml.ensemble.RandomForestClassifier.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict regression target for X.

See more: bigframes.ml.ensemble.RandomForestClassifier.predict

bigframes.ml.ensemble.RandomForestClassifier.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.ensemble.RandomForestClassifier.register

bigframes.ml.ensemble.RandomForestClassifier.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
)

Calculate evaluation metrics of the model.

See more: bigframes.ml.ensemble.RandomForestClassifier.score

bigframes.ml.ensemble.RandomForestClassifier.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.ensemble.RandomForestClassifier

Save the model to BigQuery.

See more: bigframes.ml.ensemble.RandomForestClassifier.to_gbq

bigframes.ml.ensemble.RandomForestRegressor.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.ensemble.RandomForestRegressor.repr

bigframes.ml.ensemble.RandomForestRegressor.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Build a forest of trees from the training set (X, y).

See more: bigframes.ml.ensemble.RandomForestRegressor.fit

bigframes.ml.ensemble.RandomForestRegressor.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.ensemble.RandomForestRegressor.get_params

bigframes.ml.ensemble.RandomForestRegressor.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict regression target for X.

See more: bigframes.ml.ensemble.RandomForestRegressor.predict

bigframes.ml.ensemble.RandomForestRegressor.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.ensemble.RandomForestRegressor.register

bigframes.ml.ensemble.RandomForestRegressor.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
)

Calculate evaluation metrics of the model.

See more: bigframes.ml.ensemble.RandomForestRegressor.score

bigframes.ml.ensemble.RandomForestRegressor.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.ensemble.RandomForestRegressor

Save the model to BigQuery.

See more: bigframes.ml.ensemble.RandomForestRegressor.to_gbq

bigframes.ml.ensemble.XGBClassifier.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.ensemble.XGBClassifier.repr

bigframes.ml.ensemble.XGBClassifier.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit gradient boosting model.

See more: bigframes.ml.ensemble.XGBClassifier.fit

bigframes.ml.ensemble.XGBClassifier.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.ensemble.XGBClassifier.get_params

bigframes.ml.ensemble.XGBClassifier.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict using the XGB model.

See more: bigframes.ml.ensemble.XGBClassifier.predict

bigframes.ml.ensemble.XGBClassifier.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.ensemble.XGBClassifier.register

bigframes.ml.ensemble.XGBClassifier.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
)

Return the mean accuracy on the given test data and labels.

See more: bigframes.ml.ensemble.XGBClassifier.score

bigframes.ml.ensemble.XGBClassifier.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.ensemble.XGBClassifier

Save the model to BigQuery.

See more: bigframes.ml.ensemble.XGBClassifier.to_gbq

bigframes.ml.ensemble.XGBRegressor.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.ensemble.XGBRegressor.repr

bigframes.ml.ensemble.XGBRegressor.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit gradient boosting model.

See more: bigframes.ml.ensemble.XGBRegressor.fit

bigframes.ml.ensemble.XGBRegressor.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.ensemble.XGBRegressor.get_params

bigframes.ml.ensemble.XGBRegressor.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict using the XGB model.

See more: bigframes.ml.ensemble.XGBRegressor.predict

bigframes.ml.ensemble.XGBRegressor.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.ensemble.XGBRegressor.register

bigframes.ml.ensemble.XGBRegressor.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
)

Calculate evaluation metrics of the model.

See more: bigframes.ml.ensemble.XGBRegressor.score

bigframes.ml.ensemble.XGBRegressor.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.ensemble.XGBRegressor

Save the model to BigQuery.

See more: bigframes.ml.ensemble.XGBRegressor.to_gbq

bigframes.ml.forecasting.ARIMAPlus.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.forecasting.ARIMAPlus.repr

bigframes.ml.forecasting.ARIMAPlus.detect_anomalies

detect_anomalies(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    anomaly_prob_threshold: float = 0.95
) -> bigframes.dataframe.DataFrame

Detect the anomaly data points of the input.

See more: bigframes.ml.forecasting.ARIMAPlus.detect_anomalies

bigframes.ml.forecasting.ARIMAPlus.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    transforms=None,
    id_col: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
)

API documentation for fit method.

See more: bigframes.ml.forecasting.ARIMAPlus.fit

bigframes.ml.forecasting.ARIMAPlus.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.forecasting.ARIMAPlus.get_params

bigframes.ml.forecasting.ARIMAPlus.predict

predict(
    X=None, *, horizon: int = 3, confidence_level: float = 0.95
) -> bigframes.dataframe.DataFrame

Forecast time series at future horizon.

See more: bigframes.ml.forecasting.ARIMAPlus.predict

bigframes.ml.forecasting.ARIMAPlus.predict_explain

predict_explain(
    X=None, *, horizon: int = 3, confidence_level: float = 0.95
) -> bigframes.dataframe.DataFrame

Explain Forecast time series at future horizon.

See more: bigframes.ml.forecasting.ARIMAPlus.predict_explain

bigframes.ml.forecasting.ARIMAPlus.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.forecasting.ARIMAPlus.register

bigframes.ml.forecasting.ARIMAPlus.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    id_col: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.forecasting.ARIMAPlus.score

bigframes.ml.forecasting.ARIMAPlus.summary

summary(show_all_candidate_models: bool = False) -> bigframes.dataframe.DataFrame

Summary of the evaluation metrics of the time series model.

See more: bigframes.ml.forecasting.ARIMAPlus.summary

bigframes.ml.forecasting.ARIMAPlus.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.forecasting.ARIMAPlus

Save the model to BigQuery.

See more: bigframes.ml.forecasting.ARIMAPlus.to_gbq

bigframes.ml.imported.ONNXModel.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.imported.ONNXModel.repr

bigframes.ml.imported.ONNXModel.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.imported.ONNXModel.get_params

bigframes.ml.imported.ONNXModel.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.imported.ONNXModel.predict

bigframes.ml.imported.ONNXModel.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.imported.ONNXModel.register

bigframes.ml.imported.ONNXModel.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.imported.ONNXModel

Save the model to BigQuery.

See more: bigframes.ml.imported.ONNXModel.to_gbq

bigframes.ml.imported.TensorFlowModel.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.imported.TensorFlowModel.repr

bigframes.ml.imported.TensorFlowModel.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.imported.TensorFlowModel.get_params

bigframes.ml.imported.TensorFlowModel.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.imported.TensorFlowModel.predict

bigframes.ml.imported.TensorFlowModel.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.imported.TensorFlowModel.register

bigframes.ml.imported.TensorFlowModel.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.imported.TensorFlowModel

Save the model to BigQuery.

See more: bigframes.ml.imported.TensorFlowModel.to_gbq

bigframes.ml.imported.XGBoostModel.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.imported.XGBoostModel.repr

bigframes.ml.imported.XGBoostModel.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.imported.XGBoostModel.get_params

bigframes.ml.imported.XGBoostModel.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.imported.XGBoostModel.predict

bigframes.ml.imported.XGBoostModel.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.imported.XGBoostModel.register

bigframes.ml.imported.XGBoostModel.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.imported.XGBoostModel

Save the model to BigQuery.

See more: bigframes.ml.imported.XGBoostModel.to_gbq

bigframes.ml.impute.SimpleImputer.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.impute.SimpleImputer.repr

bigframes.ml.impute.SimpleImputer.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.impute.SimpleImputer

Fit the imputer on X.

See more: bigframes.ml.impute.SimpleImputer.fit

bigframes.ml.impute.SimpleImputer.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.impute.SimpleImputer.fit_transform

bigframes.ml.impute.SimpleImputer.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.impute.SimpleImputer.get_params

bigframes.ml.impute.SimpleImputer.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.impute.SimpleImputer.to_gbq

bigframes.ml.impute.SimpleImputer.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Impute all missing values in X.

See more: bigframes.ml.impute.SimpleImputer.transform

bigframes.ml.linear_model.LinearRegression.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.linear_model.LinearRegression.repr

bigframes.ml.linear_model.LinearRegression.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit linear model.

See more: bigframes.ml.linear_model.LinearRegression.fit

bigframes.ml.linear_model.LinearRegression.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.linear_model.LinearRegression.get_params

bigframes.ml.linear_model.LinearRegression.global_explain

global_explain() -> bigframes.dataframe.DataFrame

Provide explanations for an entire linear regression model.

See more: bigframes.ml.linear_model.LinearRegression.global_explain

bigframes.ml.linear_model.LinearRegression.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict using the linear model.

See more: bigframes.ml.linear_model.LinearRegression.predict

bigframes.ml.linear_model.LinearRegression.predict_explain

predict_explain(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    top_k_features: int = 5
) -> bigframes.dataframe.DataFrame

Explain predictions for a linear regression model.

See more: bigframes.ml.linear_model.LinearRegression.predict_explain

bigframes.ml.linear_model.LinearRegression.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.linear_model.LinearRegression.register

bigframes.ml.linear_model.LinearRegression.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.linear_model.LinearRegression.score

bigframes.ml.linear_model.LinearRegression.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.linear_model.LinearRegression

Save the model to BigQuery.

See more: bigframes.ml.linear_model.LinearRegression.to_gbq

bigframes.ml.linear_model.LogisticRegression.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.linear_model.LogisticRegression.repr

bigframes.ml.linear_model.LogisticRegression.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    X_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
    y_eval: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.ml.base._T

Fit the model according to the given training data.

See more: bigframes.ml.linear_model.LogisticRegression.fit

bigframes.ml.linear_model.LogisticRegression.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.linear_model.LogisticRegression.get_params

bigframes.ml.linear_model.LogisticRegression.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict class labels for samples in X.

See more: bigframes.ml.linear_model.LogisticRegression.predict

bigframes.ml.linear_model.LogisticRegression.predict_explain

predict_explain(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    top_k_features: int = 5
) -> bigframes.dataframe.DataFrame

Explain predictions for a logistic regression model.

See more: bigframes.ml.linear_model.LogisticRegression.predict_explain

bigframes.ml.linear_model.LogisticRegression.register

register(vertex_ai_model_id: typing.Optional[str] = None) -> bigframes.ml.base._T

See more: bigframes.ml.linear_model.LogisticRegression.register

bigframes.ml.linear_model.LogisticRegression.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Return the mean accuracy on the given test data and labels.

See more: bigframes.ml.linear_model.LogisticRegression.score

bigframes.ml.linear_model.LogisticRegression.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.linear_model.LogisticRegression

Save the model to BigQuery.

See more: bigframes.ml.linear_model.LogisticRegression.to_gbq

bigframes.ml.llm.Claude3TextGenerator.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.llm.Claude3TextGenerator.repr

bigframes.ml.llm.Claude3TextGenerator.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.llm.Claude3TextGenerator.get_params

bigframes.ml.llm.Claude3TextGenerator.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    max_output_tokens: int = 128,
    top_k: int = 40,
    top_p: float = 0.95,
    max_retries: int = 0
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.llm.Claude3TextGenerator.predict

bigframes.ml.llm.Claude3TextGenerator.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.llm.Claude3TextGenerator

Save the model to BigQuery.

See more: bigframes.ml.llm.Claude3TextGenerator.to_gbq

bigframes.ml.llm.GeminiTextGenerator.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.llm.GeminiTextGenerator.repr

bigframes.ml.llm.GeminiTextGenerator.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.ml.llm.GeminiTextGenerator

Fine tune GeminiTextGenerator model.

See more: bigframes.ml.llm.GeminiTextGenerator.fit

bigframes.ml.llm.GeminiTextGenerator.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.llm.GeminiTextGenerator.get_params

bigframes.ml.llm.GeminiTextGenerator.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    temperature: float = 0.9,
    max_output_tokens: int = 8192,
    top_k: int = 40,
    top_p: float = 1.0,
    ground_with_google_search: bool = False,
    max_retries: int = 0,
    prompt: typing.Optional[
        typing.Iterable[typing.Union[str, bigframes.series.Series]]
    ] = None,
    output_schema: typing.Optional[typing.Mapping[str, str]] = None
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.llm.GeminiTextGenerator.predict

bigframes.ml.llm.GeminiTextGenerator.score

score(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    task_type: typing.Literal[
        "text_generation", "classification", "summarization", "question_answering"
    ] = "text_generation",
) -> bigframes.dataframe.DataFrame

Calculate evaluation metrics of the model.

See more: bigframes.ml.llm.GeminiTextGenerator.score

bigframes.ml.llm.GeminiTextGenerator.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.llm.GeminiTextGenerator

Save the model to BigQuery.

See more: bigframes.ml.llm.GeminiTextGenerator.to_gbq

bigframes.ml.llm.MultimodalEmbeddingGenerator.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.llm.MultimodalEmbeddingGenerator.repr

bigframes.ml.llm.MultimodalEmbeddingGenerator.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.llm.MultimodalEmbeddingGenerator.get_params

bigframes.ml.llm.MultimodalEmbeddingGenerator.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    max_retries: int = 0
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.llm.MultimodalEmbeddingGenerator.predict

bigframes.ml.llm.MultimodalEmbeddingGenerator.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.llm.MultimodalEmbeddingGenerator

Save the model to BigQuery.

See more: bigframes.ml.llm.MultimodalEmbeddingGenerator.to_gbq

bigframes.ml.llm.TextEmbeddingGenerator.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.llm.TextEmbeddingGenerator.repr

bigframes.ml.llm.TextEmbeddingGenerator.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.llm.TextEmbeddingGenerator.get_params

bigframes.ml.llm.TextEmbeddingGenerator.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    *,
    max_retries: int = 0
) -> bigframes.dataframe.DataFrame

Predict the result from input DataFrame.

See more: bigframes.ml.llm.TextEmbeddingGenerator.predict

bigframes.ml.llm.TextEmbeddingGenerator.to_gbq

to_gbq(
    model_name: str, replace: bool = False
) -> bigframes.ml.llm.TextEmbeddingGenerator

Save the model to BigQuery.

See more: bigframes.ml.llm.TextEmbeddingGenerator.to_gbq

bigframes.ml.model_selection.KFold.get_n_splits

get_n_splits() -> int

Returns the number of splitting iterations in the cross-validator.

See more: bigframes.ml.model_selection.KFold.get_n_splits

bigframes.ml.model_selection.KFold.split

split(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> typing.Generator[
    tuple[
        typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series, NoneType],
        ...,
    ],
    None,
    None,
]

Generate indices to split data into training and test set.

See more: bigframes.ml.model_selection.KFold.split

bigframes.ml.pipeline.Pipeline.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.pipeline.Pipeline.repr

bigframes.ml.pipeline.Pipeline.fit

fit(
    X: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y: typing.Optional[
        typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]
    ] = None,
) -> bigframes.ml.pipeline.Pipeline

Fit the model.

See more: bigframes.ml.pipeline.Pipeline.fit

bigframes.ml.pipeline.Pipeline.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.pipeline.Pipeline.get_params

bigframes.ml.pipeline.Pipeline.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

API documentation for predict method.

See more: bigframes.ml.pipeline.Pipeline.predict

bigframes.ml.pipeline.Pipeline.score

score(
    X: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    y: typing.Optional[
        typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series]
    ] = None,
) -> bigframes.dataframe.DataFrame

API documentation for score method.

See more: bigframes.ml.pipeline.Pipeline.score

bigframes.ml.pipeline.Pipeline.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.pipeline.Pipeline

Save the pipeline to BigQuery.

See more: bigframes.ml.pipeline.Pipeline.to_gbq

bigframes.ml.preprocessing.KBinsDiscretizer.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.repr

bigframes.ml.preprocessing.KBinsDiscretizer.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.KBinsDiscretizer

Fit the estimator.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.fit

bigframes.ml.preprocessing.KBinsDiscretizer.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.fit_transform

bigframes.ml.preprocessing.KBinsDiscretizer.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.get_params

bigframes.ml.preprocessing.KBinsDiscretizer.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.to_gbq

bigframes.ml.preprocessing.KBinsDiscretizer.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Discretize the data.

See more: bigframes.ml.preprocessing.KBinsDiscretizer.transform

bigframes.ml.preprocessing.LabelEncoder.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.LabelEncoder.repr

bigframes.ml.preprocessing.LabelEncoder.fit

fit(
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.ml.preprocessing.LabelEncoder

Fit label encoder.

See more: bigframes.ml.preprocessing.LabelEncoder.fit

bigframes.ml.preprocessing.LabelEncoder.fit_transform

fit_transform(
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

API documentation for fit_transform method.

See more: bigframes.ml.preprocessing.LabelEncoder.fit_transform

bigframes.ml.preprocessing.LabelEncoder.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.LabelEncoder.get_params

bigframes.ml.preprocessing.LabelEncoder.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.LabelEncoder.to_gbq

bigframes.ml.preprocessing.LabelEncoder.transform

transform(
    y: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Transform y using label encoding.

See more: bigframes.ml.preprocessing.LabelEncoder.transform

bigframes.ml.preprocessing.MaxAbsScaler.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.MaxAbsScaler.repr

bigframes.ml.preprocessing.MaxAbsScaler.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.MaxAbsScaler

Compute the maximum absolute value to be used for later scaling.

See more: bigframes.ml.preprocessing.MaxAbsScaler.fit

bigframes.ml.preprocessing.MaxAbsScaler.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.preprocessing.MaxAbsScaler.fit_transform

bigframes.ml.preprocessing.MaxAbsScaler.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.MaxAbsScaler.get_params

bigframes.ml.preprocessing.MaxAbsScaler.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.MaxAbsScaler.to_gbq

bigframes.ml.preprocessing.MaxAbsScaler.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Scale the data.

See more: bigframes.ml.preprocessing.MaxAbsScaler.transform

bigframes.ml.preprocessing.MinMaxScaler.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.MinMaxScaler.repr

bigframes.ml.preprocessing.MinMaxScaler.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.MinMaxScaler

Compute the minimum and maximum to be used for later scaling.

See more: bigframes.ml.preprocessing.MinMaxScaler.fit

bigframes.ml.preprocessing.MinMaxScaler.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.preprocessing.MinMaxScaler.fit_transform

bigframes.ml.preprocessing.MinMaxScaler.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.MinMaxScaler.get_params

bigframes.ml.preprocessing.MinMaxScaler.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.MinMaxScaler.to_gbq

bigframes.ml.preprocessing.MinMaxScaler.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Scale the data.

See more: bigframes.ml.preprocessing.MinMaxScaler.transform

bigframes.ml.preprocessing.OneHotEncoder.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.OneHotEncoder.repr

bigframes.ml.preprocessing.OneHotEncoder.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.OneHotEncoder

Fit OneHotEncoder to X.

See more: bigframes.ml.preprocessing.OneHotEncoder.fit

bigframes.ml.preprocessing.OneHotEncoder.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

API documentation for fit_transform method.

See more: bigframes.ml.preprocessing.OneHotEncoder.fit_transform

bigframes.ml.preprocessing.OneHotEncoder.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.OneHotEncoder.get_params

bigframes.ml.preprocessing.OneHotEncoder.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.OneHotEncoder.to_gbq

bigframes.ml.preprocessing.OneHotEncoder.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Transform X using one-hot encoding.

See more: bigframes.ml.preprocessing.OneHotEncoder.transform

bigframes.ml.preprocessing.PolynomialFeatures.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.PolynomialFeatures.repr

bigframes.ml.preprocessing.PolynomialFeatures.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.PolynomialFeatures

Compute number of output features.

See more: bigframes.ml.preprocessing.PolynomialFeatures.fit

bigframes.ml.preprocessing.PolynomialFeatures.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.preprocessing.PolynomialFeatures.fit_transform

bigframes.ml.preprocessing.PolynomialFeatures.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.PolynomialFeatures.get_params

bigframes.ml.preprocessing.PolynomialFeatures.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.PolynomialFeatures.to_gbq

bigframes.ml.preprocessing.PolynomialFeatures.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Transform data to polynomial features.

See more: bigframes.ml.preprocessing.PolynomialFeatures.transform

bigframes.ml.preprocessing.StandardScaler.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.preprocessing.StandardScaler.repr

bigframes.ml.preprocessing.StandardScaler.fit

fit(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y=None,
) -> bigframes.ml.preprocessing.StandardScaler

Compute the mean and std to be used for later scaling.

See more: bigframes.ml.preprocessing.StandardScaler.fit

bigframes.ml.preprocessing.StandardScaler.fit_transform

fit_transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
    y: typing.Optional[
        typing.Union[
            bigframes.dataframe.DataFrame,
            bigframes.series.Series,
            pandas.core.frame.DataFrame,
            pandas.core.series.Series,
        ]
    ] = None,
) -> bigframes.dataframe.DataFrame

Fit to data, then transform it.

See more: bigframes.ml.preprocessing.StandardScaler.fit_transform

bigframes.ml.preprocessing.StandardScaler.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.preprocessing.StandardScaler.get_params

bigframes.ml.preprocessing.StandardScaler.to_gbq

to_gbq(model_name: str, replace: bool = False) -> bigframes.ml.base._T

Save the transformer as a BigQuery model.

See more: bigframes.ml.preprocessing.StandardScaler.to_gbq

bigframes.ml.preprocessing.StandardScaler.transform

transform(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Perform standardization by centering and scaling.

See more: bigframes.ml.preprocessing.StandardScaler.transform

bigframes.ml.remote.VertexAIModel.repr

__repr__()

Print the estimator's constructor with all non-default parameter values.

See more: bigframes.ml.remote.VertexAIModel.repr

bigframes.ml.remote.VertexAIModel.get_params

get_params(deep: bool = True) -> typing.Dict[str, typing.Any]

Get parameters for this estimator.

See more: bigframes.ml.remote.VertexAIModel.get_params

bigframes.ml.remote.VertexAIModel.predict

predict(
    X: typing.Union[
        bigframes.dataframe.DataFrame,
        bigframes.series.Series,
        pandas.core.frame.DataFrame,
        pandas.core.series.Series,
    ],
) -> bigframes.dataframe.DataFrame

Predict the result from the input DataFrame.

See more: bigframes.ml.remote.VertexAIModel.predict

bigframes.operations.ai.AIAccessor.classify

classify(
    instruction: str,
    model,
    labels: typing.Sequence[str],
    output_column: str = "result",
    ground_with_google_search: bool = False,
)

Classifies the rows of dataframes based on user instruction into the provided labels.

See more: bigframes.operations.ai.AIAccessor.classify

bigframes.operations.ai.AIAccessor.filter

filter(instruction: str, model, ground_with_google_search: bool = False)

Filters the DataFrame with the semantics of the user instruction.

See more: bigframes.operations.ai.AIAccessor.filter

bigframes.operations.ai.AIAccessor.forecast

forecast(
    timestamp_column: str,
    data_column: str,
    *,
    model: str = "TimesFM 2.0",
    id_columns: typing.Optional[typing.Iterable[str]] = None,
    horizon: int = 10,
    confidence_level: float = 0.95
)

Forecast time series at future horizon.

See more: bigframes.operations.ai.AIAccessor.forecast

bigframes.operations.ai.AIAccessor.join

join(other, instruction: str, model, ground_with_google_search: bool = False)

Joines two dataframes by applying the instruction over each pair of rows from the left and right table.

See more: bigframes.operations.ai.AIAccessor.join

bigframes.operations.ai.AIAccessor.map

map(
    instruction: str,
    model,
    output_schema: typing.Optional[typing.Dict[str, str]] = None,
    ground_with_google_search: bool = False,
)

Maps the DataFrame with the semantics of the user instruction.

See more: bigframes.operations.ai.AIAccessor.map

bigframes.operations.ai.AIAccessor.search

search(
    search_column: str,
    query: str,
    top_k: int,
    model,
    score_column: typing.Optional[str] = None,
)

Performs AI semantic search on the DataFrame.

See more: bigframes.operations.ai.AIAccessor.search

bigframes.operations.ai.AIAccessor.sim_join

sim_join(
    other,
    left_on: str,
    right_on: str,
    model,
    top_k: int = 3,
    score_column: typing.Optional[str] = None,
    max_rows: int = 1000,
)

Joins two dataframes based on the similarity of the specified columns.

See more: bigframes.operations.ai.AIAccessor.sim_join

bigframes.operations.blob.BlobAccessor.audio_transcribe

audio_transcribe(
    *,
    engine: typing.Literal["bigquery"] = "bigquery",
    connection: typing.Optional[str] = None,
    model_name: typing.Optional[
        typing.Literal["gemini-2.0-flash-001", "gemini-2.0-flash-lite-001"]
    ] = None,
    verbose: bool = False
) -> bigframes.series.Series

Transcribe audio content using a Gemini multimodal model.

See more: bigframes.operations.blob.BlobAccessor.audio_transcribe

bigframes.operations.blob.BlobAccessor.authorizer

authorizer() -> bigframes.series.Series

Authorizers of the Blob.

See more: bigframes.operations.blob.BlobAccessor.authorizer

bigframes.operations.blob.BlobAccessor.content_type

content_type() -> bigframes.series.Series

Retrieve the content type of the Blob.

See more: bigframes.operations.blob.BlobAccessor.content_type

bigframes.operations.blob.BlobAccessor.display

display(
    n: int = 3,
    *,
    content_type: str = "",
    width: typing.Optional[int] = None,
    height: typing.Optional[int] = None
)

Display the blob content in the IPython Notebook environment.

See more: bigframes.operations.blob.BlobAccessor.display

bigframes.operations.blob.BlobAccessor.exif

exif(
    *,
    engine: typing.Literal[None, "pillow"] = None,
    connection: typing.Optional[str] = None,
    max_batching_rows: int = 8192,
    container_cpu: typing.Union[float, int] = 0.33,
    container_memory: str = "512Mi",
    verbose: bool = False
) -> bigframes.series.Series

Extract EXIF data.

See more: bigframes.operations.blob.BlobAccessor.exif

bigframes.operations.blob.BlobAccessor.get_runtime_json_str

get_runtime_json_str(
    mode: str = "R", *, with_metadata: bool = False
) -> bigframes.series.Series

Get the runtime (contains signed URL to access gcs data) and apply the ToJSONSTring transformation.

See more: bigframes.operations.blob.BlobAccessor.get_runtime_json_str

bigframes.operations.blob.BlobAccessor.image_blur

image_blur(
    ksize: tuple[int, int],
    *,
    engine: typing.Literal[None, "opencv"] = None,
    dst: typing.Optional[typing.Union[str, bigframes.series.Series]] = None,
    connection: typing.Optional[str] = None,
    max_batching_rows: int = 8192,
    container_cpu: typing.Union[float, int] = 0.33,
    container_memory: str = "512Mi",
    verbose: bool = False
) -> bigframes.series.Series

Blurs images.

See more: bigframes.operations.blob.BlobAccessor.image_blur

bigframes.operations.blob.BlobAccessor.image_normalize

image_normalize(
    *,
    engine: typing.Literal[None, "opencv"] = None,
    alpha: float = 1.0,
    beta: float = 0.0,
    norm_type: str = "l2",
    dst: typing.Optional[typing.Union[str, bigframes.series.Series]] = None,
    connection: typing.Optional[str] = None,
    max_batching_rows: int = 8192,
    container_cpu: typing.Union[float, int] = 0.33,
    container_memory: str = "512Mi",
    verbose: bool = False
) -> bigframes.series.Series

Normalize images.

See more: bigframes.operations.blob.BlobAccessor.image_normalize

bigframes.operations.blob.BlobAccessor.image_resize

image_resize(
    dsize: tuple[int, int] = (0, 0),
    *,
    engine: typing.Literal[None, "opencv"] = None,
    fx: float = 0.0,
    fy: float = 0.0,
    dst: typing.Optional[typing.Union[str, bigframes.series.Series]] = None,
    connection: typing.Optional[str] = None,
    max_batching_rows: int = 8192,
    container_cpu: typing.Union[float, int] = 0.33,
    container_memory: str = "512Mi",
    verbose: bool = False
)

Resize images.

See more: bigframes.operations.blob.BlobAccessor.image_resize

bigframes.operations.blob.BlobAccessor.md5_hash

md5_hash() -> bigframes.series.Series

Retrieve the md5 hash of the Blob.

See more: bigframes.operations.blob.BlobAccessor.md5_hash

bigframes.operations.blob.BlobAccessor.metadata

metadata() -> bigframes.series.Series

Retrieve the metadata of the Blob.

See more: bigframes.operations.blob.BlobAccessor.metadata

bigframes.operations.blob.BlobAccessor.pdf_chunk

pdf_chunk(
    *,
    engine: typing.Literal[None, "pypdf"] = None,
    connection: typing.Optional[str] = None,
    chunk_size: int = 2000,
    overlap_size: int = 200,
    max_batching_rows: int = 1,
    container_cpu: typing.Union[float, int] = 2,
    container_memory: str = "1Gi",
    verbose: bool = False
) -> bigframes.series.Series

Extracts and chunks text from PDF URLs and saves the text as arrays of strings.

See more: bigframes.operations.blob.BlobAccessor.pdf_chunk

bigframes.operations.blob.BlobAccessor.pdf_extract

pdf_extract(
    *,
    engine: typing.Literal[None, "pypdf"] = None,
    connection: typing.Optional[str] = None,
    max_batching_rows: int = 1,
    container_cpu: typing.Union[float, int] = 2,
    container_memory: str = "1Gi",
    verbose: bool = False
) -> bigframes.series.Series

Extracts text from PDF URLs and saves the text as string.

See more: bigframes.operations.blob.BlobAccessor.pdf_extract

bigframes.operations.blob.BlobAccessor.read_url

read_url() -> bigframes.series.Series

Retrieve the read URL of the Blob.

See more: bigframes.operations.blob.BlobAccessor.read_url

bigframes.operations.blob.BlobAccessor.size

size() -> bigframes.series.Series

Retrieve the file size of the Blob.

See more: bigframes.operations.blob.BlobAccessor.size

bigframes.operations.blob.BlobAccessor.updated

updated() -> bigframes.series.Series

Retrieve the updated time of the Blob.

See more: bigframes.operations.blob.BlobAccessor.updated

bigframes.operations.blob.BlobAccessor.uri

uri() -> bigframes.series.Series

URIs of the Blob.

See more: bigframes.operations.blob.BlobAccessor.uri

bigframes.operations.blob.BlobAccessor.version

version() -> bigframes.series.Series

Versions of the Blob.

See more: bigframes.operations.blob.BlobAccessor.version

bigframes.operations.blob.BlobAccessor.write_url

write_url() -> bigframes.series.Series

Retrieve the write URL of the Blob.

See more: bigframes.operations.blob.BlobAccessor.write_url

bigframes.operations.datetimes.DatetimeMethods.day_name

day_name() -> bigframes.series.Series

Return the day names in english.

See more: bigframes.operations.datetimes.DatetimeMethods.day_name

bigframes.operations.datetimes.DatetimeMethods.floor

floor(freq: str) -> bigframes.series.Series

Perform floor operation on the data to the specified freq.

See more: bigframes.operations.datetimes.DatetimeMethods.floor

bigframes.operations.datetimes.DatetimeMethods.isocalendar

isocalendar() -> bigframes.dataframe.DataFrame

Calculate year, week, and day according to the ISO 8601 standard.

See more: bigframes.operations.datetimes.DatetimeMethods.isocalendar

bigframes.operations.datetimes.DatetimeMethods.normalize

normalize() -> bigframes.series.Series

Convert times to midnight.

See more: bigframes.operations.datetimes.DatetimeMethods.normalize

bigframes.operations.datetimes.DatetimeMethods.strftime

strftime(date_format: str) -> bigframes.series.Series

Convert to string Series using specified date_format.

See more: bigframes.operations.datetimes.DatetimeMethods.strftime

bigframes.operations.datetimes.DatetimeMethods.total_seconds

total_seconds() -> bigframes.series.Series

Return total duration of each element expressed in seconds.

See more: bigframes.operations.datetimes.DatetimeMethods.total_seconds

bigframes.operations.lists.ListAccessor.getitem

__getitem__(key: typing.Union[int, slice]) -> bigframes.series.Series

Index or slice lists in the Series.

See more: bigframes.operations.lists.ListAccessor.getitem

bigframes.operations.lists.ListAccessor.len

len()

Compute the length of each list in the Series.

See more: bigframes.operations.lists.ListAccessor.len

bigframes.operations.plotting.PlotAccessor.area

area(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    stacked: bool = True,
    **kwargs
)

Draw a stacked area plot.

See more: bigframes.operations.plotting.PlotAccessor.area

bigframes.operations.plotting.PlotAccessor.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.operations.plotting.PlotAccessor.bar

bigframes.operations.plotting.PlotAccessor.barh

barh(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a horizontal bar plot.

See more: bigframes.operations.plotting.PlotAccessor.barh

bigframes.operations.plotting.PlotAccessor.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.operations.plotting.PlotAccessor.hist

bigframes.operations.plotting.PlotAccessor.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.operations.plotting.PlotAccessor.line

bigframes.operations.plotting.PlotAccessor.pie

pie(y: typing.Optional[typing.Hashable] = None, **kwargs)

Generate a pie plot.

See more: bigframes.operations.plotting.PlotAccessor.pie

bigframes.operations.plotting.PlotAccessor.scatter

scatter(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    s: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    c: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    **kwargs
)

Create a scatter plot with varying marker point size and color.

See more: bigframes.operations.plotting.PlotAccessor.scatter

bigframes.operations.plotting.PlotAccessor

PlotAccessor(data)

Make plots of Series or DataFrame with the matplotlib backend.

See more: bigframes.operations.plotting.PlotAccessor

bigframes.operations.strings.StringMethods.capitalize

capitalize() -> bigframes.operations.strings.T

Convert strings in the Series/Index to be capitalized.

See more: bigframes.operations.strings.StringMethods.capitalize

bigframes.operations.strings.StringMethods.cat

cat(
    others: typing.Union[
        str, bigframes.core.indexes.base.Index, bigframes.series.Series
    ],
    *,
    join: typing.Literal["outer", "left"] = "left"
) -> bigframes.operations.strings.T

Concatenate strings in the Series/Index with given separator.

See more: bigframes.operations.strings.StringMethods.cat

bigframes.operations.strings.StringMethods.center

center(width: int, fillchar: str = " ") -> bigframes.operations.strings.T

Pad left and right side of strings in the Series/Index.

See more: bigframes.operations.strings.StringMethods.center

bigframes.operations.strings.StringMethods.contains

contains(
    pat, case: bool = True, flags: int = 0, *, regex: bool = True
) -> bigframes.operations.strings.T

Test if pattern or regex is contained within a string of a Series or Index.

See more: bigframes.operations.strings.StringMethods.contains

bigframes.operations.strings.StringMethods.endswith

endswith(pat: typing.Union[str, tuple[str, ...]]) -> bigframes.operations.strings.T

Test if the end of each string element matches a pattern.

See more: bigframes.operations.strings.StringMethods.endswith

bigframes.operations.strings.StringMethods.extract

extract(pat: str, flags: int = 0) -> bigframes.dataframe.DataFrame

Extract capture groups in the regex pat as columns in a DataFrame.

See more: bigframes.operations.strings.StringMethods.extract

bigframes.operations.strings.StringMethods.find

find(
    sub: str, start: typing.Optional[int] = None, end: typing.Optional[int] = None
) -> bigframes.operations.strings.T

Return lowest indexes in each strings in the Series/Index.

See more: bigframes.operations.strings.StringMethods.find

bigframes.operations.strings.StringMethods.fullmatch

fullmatch(pat, case=True, flags=0) -> bigframes.operations.strings.T

Determine if each string entirely matches a regular expression.

See more: bigframes.operations.strings.StringMethods.fullmatch

bigframes.operations.strings.StringMethods.get

get(i: int) -> bigframes.operations.strings.T

Extract element from each component at specified position or with specified key.

See more: bigframes.operations.strings.StringMethods.get

bigframes.operations.strings.StringMethods.isalnum

isalnum() -> bigframes.operations.strings.T

Check whether all characters in each string are alphanumeric.

See more: bigframes.operations.strings.StringMethods.isalnum

bigframes.operations.strings.StringMethods.isalpha

isalpha() -> bigframes.operations.strings.T

Check whether all characters in each string are alphabetic.

See more: bigframes.operations.strings.StringMethods.isalpha

bigframes.operations.strings.StringMethods.isdecimal

isdecimal() -> bigframes.operations.strings.T

Check whether all characters in each string are decimal.

See more: bigframes.operations.strings.StringMethods.isdecimal

bigframes.operations.strings.StringMethods.isdigit

isdigit() -> bigframes.operations.strings.T

Check whether all characters in each string are digits.

See more: bigframes.operations.strings.StringMethods.isdigit

bigframes.operations.strings.StringMethods.islower

islower() -> bigframes.operations.strings.T

Check whether all characters in each string are lowercase.

See more: bigframes.operations.strings.StringMethods.islower

bigframes.operations.strings.StringMethods.isnumeric

isnumeric() -> bigframes.operations.strings.T

Check whether all characters in each string are numeric.

See more: bigframes.operations.strings.StringMethods.isnumeric

bigframes.operations.strings.StringMethods.isspace

isspace() -> bigframes.operations.strings.T

Check whether all characters in each string are whitespace.

See more: bigframes.operations.strings.StringMethods.isspace

bigframes.operations.strings.StringMethods.isupper

isupper() -> bigframes.operations.strings.T

Check whether all characters in each string are uppercase.

See more: bigframes.operations.strings.StringMethods.isupper

bigframes.operations.strings.StringMethods.join

join(sep: str) -> bigframes.operations.strings.T

Join lists contained as elements in the Series/Index with passed delimiter.

See more: bigframes.operations.strings.StringMethods.join

bigframes.operations.strings.StringMethods.len

len() -> bigframes.operations.strings.T

Compute the length of each element in the Series/Index.

See more: bigframes.operations.strings.StringMethods.len

bigframes.operations.strings.StringMethods.ljust

ljust(width, fillchar=" ") -> bigframes.operations.strings.T

Pad right side of strings in the Series/Index up to width.

See more: bigframes.operations.strings.StringMethods.ljust

bigframes.operations.strings.StringMethods.lower

lower() -> bigframes.operations.strings.T

Convert strings in the Series/Index to lowercase.

See more: bigframes.operations.strings.StringMethods.lower

bigframes.operations.strings.StringMethods.lstrip

lstrip(to_strip: typing.Optional[str] = None) -> bigframes.operations.strings.T

Remove leading characters.

See more: bigframes.operations.strings.StringMethods.lstrip

bigframes.operations.strings.StringMethods.match

match(pat, case=True, flags=0) -> bigframes.operations.strings.T

Determine if each string starts with a match of a regular expression.

See more: bigframes.operations.strings.StringMethods.match

bigframes.operations.strings.StringMethods.pad

pad(width, side="left", fillchar=" ") -> bigframes.operations.strings.T

Pad strings in the Series/Index up to width.

See more: bigframes.operations.strings.StringMethods.pad

bigframes.operations.strings.StringMethods.repeat

repeat(repeats: int) -> bigframes.operations.strings.T

Duplicate each string in the Series or Index.

See more: bigframes.operations.strings.StringMethods.repeat

bigframes.operations.strings.StringMethods.replace

replace(
    pat: typing.Union[str, re.Pattern],
    repl: str,
    *,
    case: typing.Optional[bool] = None,
    flags: int = 0,
    regex: bool = False
) -> bigframes.operations.strings.T

Replace each occurrence of pattern/regex in the Series/Index.

See more: bigframes.operations.strings.StringMethods.replace

bigframes.operations.strings.StringMethods.reverse

reverse() -> bigframes.operations.strings.T

Reverse strings in the Series.

See more: bigframes.operations.strings.StringMethods.reverse

bigframes.operations.strings.StringMethods.rjust

rjust(width, fillchar=" ") -> bigframes.operations.strings.T

Pad left side of strings in the Series/Index up to width.

See more: bigframes.operations.strings.StringMethods.rjust

bigframes.operations.strings.StringMethods.rstrip

rstrip(to_strip: typing.Optional[str] = None) -> bigframes.operations.strings.T

Remove trailing characters.

See more: bigframes.operations.strings.StringMethods.rstrip

bigframes.operations.strings.StringMethods.slice

slice(
    start: typing.Optional[int] = None, stop: typing.Optional[int] = None
) -> bigframes.operations.strings.T

Slice substrings from each element in the Series or Index.

See more: bigframes.operations.strings.StringMethods.slice

bigframes.operations.strings.StringMethods.split

split(
    pat: str = " ", regex: typing.Optional[bool] = None
) -> bigframes.operations.strings.T

Split strings around given separator/delimiter.

See more: bigframes.operations.strings.StringMethods.split

bigframes.operations.strings.StringMethods.startswith

startswith(
    pat: typing.Union[str, tuple[str, ...]],
) -> bigframes.operations.strings.T

Test if the start of each string element matches a pattern.

See more: bigframes.operations.strings.StringMethods.startswith

bigframes.operations.strings.StringMethods.strip

strip(to_strip: typing.Optional[str] = None) -> bigframes.operations.strings.T

Remove leading and trailing characters.

See more: bigframes.operations.strings.StringMethods.strip

bigframes.operations.strings.StringMethods.to_blob

to_blob(connection: typing.Optional[str] = None) -> bigframes.operations.strings.T

Create a BigFrames Blob series from a series of URIs.

See more: bigframes.operations.strings.StringMethods.to_blob

bigframes.operations.strings.StringMethods.upper

upper() -> bigframes.operations.strings.T

Convert strings in the Series/Index to uppercase.

See more: bigframes.operations.strings.StringMethods.upper

bigframes.operations.strings.StringMethods.zfill

zfill(width: int) -> bigframes.operations.strings.T

Pad strings in the Series/Index by prepending '0' characters.

See more: bigframes.operations.strings.StringMethods.zfill

bigframes.operations.structs.StructAccessor.explode

explode() -> bigframes.dataframe.DataFrame

Extract all child fields of a struct as a DataFrame.

See more: bigframes.operations.structs.StructAccessor.explode

bigframes.operations.structs.StructAccessor.field

field(name_or_index: str | int) -> bigframes.series.Series

Extract a child field of a struct as a Series.

See more: bigframes.operations.structs.StructAccessor.field

bigframes.operations.structs.StructFrameAccessor.explode

explode(column, *, separator: str = ".") -> bigframes.dataframe.DataFrame

Extract all child fields of struct column(s) and add to the DataFrame.

See more: bigframes.operations.structs.StructFrameAccessor.explode

bigframes.pandas.ArrowDtype.__from_arrow__

__from_arrow__(array: pyarrow.lib.Array | pyarrow.lib.ChunkedArray)

Construct IntegerArray/FloatingArray from pyarrow Array/ChunkedArray.

See more: bigframes.pandas.ArrowDtype.from_arrow

bigframes.pandas.ArrowDtype.construct_array_type

construct_array_type() -> type_t[ArrowExtensionArray]

Return the array type associated with this dtype.

See more: bigframes.pandas.ArrowDtype.construct_array_type

bigframes.pandas.ArrowDtype.construct_from_string

construct_from_string(string: str) -> pandas.core.dtypes.dtypes.ArrowDtype

Construct this type from a string.

See more: bigframes.pandas.ArrowDtype.construct_from_string

bigframes.pandas.BooleanDtype.__from_arrow__

__from_arrow__(array: pyarrow.Array | pyarrow.ChunkedArray) -> BooleanArray

Construct BooleanArray from pyarrow Array/ChunkedArray.

See more: bigframes.pandas.BooleanDtype.from_arrow

bigframes.pandas.BooleanDtype.construct_array_type

construct_array_type() -> type_t[BooleanArray]

Return the array type associated with this dtype.

See more: bigframes.pandas.BooleanDtype.construct_array_type

bigframes.pandas.DataFrame.abs

__abs__() -> bigframes.dataframe.DataFrame

Return the absolute value of the argument.

See more: bigframes.pandas.DataFrame.abs

bigframes.pandas.DataFrame.add

__add__(other) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, column-wise, using arithmetic operator +.

See more: bigframes.pandas.DataFrame.add

bigframes.pandas.DataFrame.and

__and__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise AND of DataFrame and other, element-wise, using operator &.

See more: bigframes.pandas.DataFrame.and

bigframes.pandas.DataFrame.array

__array__(dtype=None, copy: typing.Optional[bool] = None) -> numpy.ndarray

Returns the rows as NumPy array.

See more: bigframes.pandas.DataFrame.array

bigframes.pandas.DataFrame.__array_ufunc__

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

Used to support numpy ufuncs.

See more: bigframes.pandas.DataFrame.array_ufunc

bigframes.pandas.DataFrame.eq

__eq__(other) -> bigframes.dataframe.DataFrame

Check equality of DataFrame and other, element-wise, using logical operator ==.

See more: bigframes.pandas.DataFrame.eq

bigframes.pandas.DataFrame.floordiv

__floordiv__(other)

Get integer division of DataFrame by other, using arithmetic operator //.

See more: bigframes.pandas.DataFrame.floordiv

bigframes.pandas.DataFrame.ge

__ge__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is greater than or equal to other, element-wise, using logical operator >=.

See more: bigframes.pandas.DataFrame.ge

bigframes.pandas.DataFrame.getitem

Gets the specified column(s) from the DataFrame.

See more: bigframes.pandas.DataFrame.getitem

bigframes.pandas.DataFrame.gt

__gt__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is greater than other, element-wise, using logical operator >.

See more: bigframes.pandas.DataFrame.gt

bigframes.pandas.DataFrame.invert

__invert__() -> bigframes.dataframe.DataFrame

Returns the bitwise inversion of the DataFrame, element-wise using operator ````.

See more: bigframes.pandas.DataFrame.invert

bigframes.pandas.DataFrame.le

__le__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is less than or equal to other, element-wise, using logical operator <=.

See more: bigframes.pandas.DataFrame.le

bigframes.pandas.DataFrame.len

__len__()

Returns number of rows in the DataFrame, serves len operator.

See more: bigframes.pandas.DataFrame.len

bigframes.pandas.DataFrame.lt

__lt__(other) -> bigframes.dataframe.DataFrame

Check whether DataFrame is less than other, element-wise, using logical operator <.

See more: bigframes.pandas.DataFrame.lt

bigframes.pandas.DataFrame.matmul

__matmul__(other) -> bigframes.dataframe.DataFrame

Compute the matrix multiplication between the DataFrame and other, using operator @.

See more: bigframes.pandas.DataFrame.matmul

bigframes.pandas.DataFrame.mod

__mod__(other)

Get modulo of DataFrame with other, element-wise, using operator %.

See more: bigframes.pandas.DataFrame.mod

bigframes.pandas.DataFrame.mul

__mul__(other)

Get multiplication of DataFrame with other, element-wise, using operator *.

See more: bigframes.pandas.DataFrame.mul

bigframes.pandas.DataFrame.ne

__ne__(other) -> bigframes.dataframe.DataFrame

Check inequality of DataFrame and other, element-wise, using logical operator !=.

See more: bigframes.pandas.DataFrame.ne

bigframes.pandas.DataFrame.or

__or__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise OR of DataFrame and other, element-wise, using operator |.

See more: bigframes.pandas.DataFrame.or

bigframes.pandas.DataFrame.pow

__pow__(other)

Get exponentiation of DataFrame with other, element-wise, using operator **.

See more: bigframes.pandas.DataFrame.pow

bigframes.pandas.DataFrame.radd

__radd__(other) -> bigframes.dataframe.DataFrame

Get addition of other and DataFrame, element-wise (binary operator +).

See more: bigframes.pandas.DataFrame.radd

bigframes.pandas.DataFrame.rand

__rand__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise AND of DataFrame and other, element-wise, using operator &.

See more: bigframes.pandas.DataFrame.rand

bigframes.pandas.DataFrame.repr

__repr__() -> str

Converts a DataFrame to a string.

See more: bigframes.pandas.DataFrame.repr

bigframes.pandas.DataFrame.rfloordiv

__rfloordiv__(other)

Get integer divison of other by DataFrame.

See more: bigframes.pandas.DataFrame.rfloordiv

bigframes.pandas.DataFrame.rmod

__rmod__(other)

Get integer divison of other by DataFrame.

See more: bigframes.pandas.DataFrame.rmod

bigframes.pandas.DataFrame.rmul

__rmul__(other)

Get multiplication of DataFrame with other, element-wise, using operator *.

See more: bigframes.pandas.DataFrame.rmul

bigframes.pandas.DataFrame.ror

__ror__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise OR of DataFrame and other, element-wise, using operator |.

See more: bigframes.pandas.DataFrame.ror

bigframes.pandas.DataFrame.rpow

__rpow__(other)

Get exponentiation of other with DataFrame, element-wise, using operator **.

See more: bigframes.pandas.DataFrame.rpow

bigframes.pandas.DataFrame.rsub

__rsub__(other)

Get subtraction of DataFrame from other, element-wise, using operator -.

See more: bigframes.pandas.DataFrame.rsub

bigframes.pandas.DataFrame.rtruediv

__rtruediv__(other)

Get division of other by DataFrame, element-wise, using operator /.

See more: bigframes.pandas.DataFrame.rtruediv

bigframes.pandas.DataFrame.rxor

__rxor__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise XOR of DataFrame and other, element-wise, using operator ^.

See more: bigframes.pandas.DataFrame.rxor

bigframes.pandas.DataFrame.setitem

__setitem__(
    key: str | list[str] | pandas.Index, value: SingleItemValue | MultiItemValue
)

Modify or insert a column into the DataFrame.

See more: bigframes.pandas.DataFrame.setitem

bigframes.pandas.DataFrame.sub

__sub__(other)

Get subtraction of other from DataFrame, element-wise, using operator -.

See more: bigframes.pandas.DataFrame.sub

bigframes.pandas.DataFrame.truediv

__truediv__(other)

Get division of DataFrame by other, element-wise, using operator /.

See more: bigframes.pandas.DataFrame.truediv

bigframes.pandas.DataFrame.xor

__xor__(
    other: bool | int | bigframes.series.Series,
) -> bigframes.dataframe.DataFrame

Get bitwise XOR of DataFrame and other, element-wise, using operator ^.

See more: bigframes.pandas.DataFrame.xor

bigframes.pandas.DataFrame.abs

abs() -> bigframes.dataframe.DataFrame

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

See more: bigframes.pandas.DataFrame.abs

bigframes.pandas.DataFrame.add

add(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, element-wise (binary operator +).

See more: bigframes.pandas.DataFrame.add

bigframes.pandas.DataFrame.add_prefix

add_prefix(
    prefix: str, axis: int | str | None = None
) -> bigframes.dataframe.DataFrame

Prefix labels with string prefix.

See more: bigframes.pandas.DataFrame.add_prefix

bigframes.pandas.DataFrame.add_suffix

add_suffix(
    suffix: str, axis: int | str | None = None
) -> bigframes.dataframe.DataFrame

Suffix labels with string suffix.

See more: bigframes.pandas.DataFrame.add_suffix

bigframes.pandas.DataFrame.agg

agg(func) -> bigframes.dataframe.DataFrame | bigframes.series.Series

Aggregate using one or more operations over columns.

See more: bigframes.pandas.DataFrame.agg

bigframes.pandas.DataFrame.aggregate

aggregate(func) -> bigframes.dataframe.DataFrame | bigframes.series.Series

Aggregate using one or more operations over columns.

See more: bigframes.pandas.DataFrame.aggregate

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.align

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.all

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.any

bigframes.pandas.DataFrame.apply

apply(func, *, axis=0, args: typing.Tuple = (), **kwargs)

Apply a function along an axis of the DataFrame.

See more: bigframes.pandas.DataFrame.apply

bigframes.pandas.DataFrame.applymap

applymap(
    func, na_action: typing.Optional[str] = None
) -> bigframes.dataframe.DataFrame

Apply a function to a Dataframe elementwise.

See more: bigframes.pandas.DataFrame.applymap

bigframes.pandas.DataFrame.area

area(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    stacked: bool = True,
    **kwargs
)

Draw a stacked area plot.

See more: bigframes.pandas.DataFrame.area

bigframes.pandas.DataFrame.assign

assign(**kwargs) -> bigframes.dataframe.DataFrame

Assign new columns to a DataFrame.

See more: bigframes.pandas.DataFrame.assign

bigframes.pandas.DataFrame.astype

astype(
    dtype: typing.Union[
        typing.Literal[
            "boolean",
            "Float64",
            "Int64",
            "int64[pyarrow]",
            "string",
            "string[pyarrow]",
            "timestamp[us, tz=UTC][pyarrow]",
            "timestamp[us][pyarrow]",
            "date32[day][pyarrow]",
            "time64[us][pyarrow]",
            "decimal128(38, 9)[pyarrow]",
            "decimal256(76, 38)[pyarrow]",
            "binary[pyarrow]",
            "duration[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,
        geopandas.array.GeometryDtype,
        type,
        dict[
            str,
            typing.Union[
                typing.Literal[
                    "boolean",
                    "Float64",
                    "Int64",
                    "int64[pyarrow]",
                    "string",
                    "string[pyarrow]",
                    "timestamp[us, tz=UTC][pyarrow]",
                    "timestamp[us][pyarrow]",
                    "date32[day][pyarrow]",
                    "time64[us][pyarrow]",
                    "decimal128(38, 9)[pyarrow]",
                    "decimal256(76, 38)[pyarrow]",
                    "binary[pyarrow]",
                    "duration[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,
                geopandas.array.GeometryDtype,
            ],
        ],
    ],
    *,
    errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.dataframe.DataFrame

Cast a pandas object to a specified dtype dtype.

See more: bigframes.pandas.DataFrame.astype

bigframes.pandas.DataFrame.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.pandas.DataFrame.bar

bigframes.pandas.DataFrame.bfill

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

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

See more: bigframes.pandas.DataFrame.bfill

bigframes.pandas.DataFrame.cache

cache()

Materializes the DataFrame to a temporary table.

See more: bigframes.pandas.DataFrame.cache

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.combine

bigframes.pandas.DataFrame.combine_first

combine_first(other: bigframes.dataframe.DataFrame)

Update null elements with value in the same location in other.

See more: bigframes.pandas.DataFrame.combine_first

bigframes.pandas.DataFrame.copy

copy() -> bigframes.dataframe.DataFrame

Make a copy of this object's indices and data.

See more: bigframes.pandas.DataFrame.copy

bigframes.pandas.DataFrame.corr

corr(
    method="pearson", min_periods=None, numeric_only=False
) -> bigframes.dataframe.DataFrame

Compute pairwise correlation of columns, excluding NA/null values.

See more: bigframes.pandas.DataFrame.corr

bigframes.pandas.DataFrame.corrwith

corrwith(
    other: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    *,
    numeric_only: bool = False
)

Compute pairwise correlation.

See more: bigframes.pandas.DataFrame.corrwith

bigframes.pandas.DataFrame.count

count(*, numeric_only: bool = False) -> bigframes.series.Series

Count non-NA cells for each column.

See more: bigframes.pandas.DataFrame.count

bigframes.pandas.DataFrame.cov

cov(*, numeric_only: bool = False) -> bigframes.dataframe.DataFrame

Compute pairwise covariance of columns, excluding NA/null values.

See more: bigframes.pandas.DataFrame.cov

bigframes.pandas.DataFrame.cummax

cummax() -> bigframes.dataframe.DataFrame

Return cumulative maximum over columns.

See more: bigframes.pandas.DataFrame.cummax

bigframes.pandas.DataFrame.cummin

cummin() -> bigframes.dataframe.DataFrame

Return cumulative minimum over columns.

See more: bigframes.pandas.DataFrame.cummin

bigframes.pandas.DataFrame.cumprod

cumprod() -> bigframes.dataframe.DataFrame

Return cumulative product over columns.

See more: bigframes.pandas.DataFrame.cumprod

bigframes.pandas.DataFrame.cumsum

cumsum()

Return cumulative sum over columns.

See more: bigframes.pandas.DataFrame.cumsum

bigframes.pandas.DataFrame.describe

describe(
    include: typing.Union[None, typing.Literal["all"]] = None,
) -> bigframes.dataframe.DataFrame

Generate descriptive statistics.

See more: bigframes.pandas.DataFrame.describe

bigframes.pandas.DataFrame.diff

diff(periods: int = 1) -> bigframes.dataframe.DataFrame

First discrete difference of element.

See more: bigframes.pandas.DataFrame.diff

bigframes.pandas.DataFrame.div

div(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.pandas.DataFrame.div

bigframes.pandas.DataFrame.divide

divide(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.pandas.DataFrame.divide

bigframes.pandas.DataFrame.dot

dot(other: _DataFrameOrSeries) -> _DataFrameOrSeries

Compute the matrix multiplication between the DataFrame and other.

See more: bigframes.pandas.DataFrame.dot

bigframes.pandas.DataFrame.drop

Drop specified labels from columns.

See more: bigframes.pandas.DataFrame.drop

bigframes.pandas.DataFrame.drop_duplicates

drop_duplicates(
    subset: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    *,
    keep: str = "first"
) -> bigframes.dataframe.DataFrame

Return DataFrame with duplicate rows removed.

See more: bigframes.pandas.DataFrame.drop_duplicates

bigframes.pandas.DataFrame.droplevel

droplevel(
    level: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    axis: int | str = 0,
)

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

See more: bigframes.pandas.DataFrame.droplevel

bigframes.pandas.DataFrame.dropna

dropna(
    *,
    axis: int | str = 0,
    how: str = "any",
    thresh: typing.Optional[int] = None,
    subset: typing.Union[
        None, typing.Hashable, typing.Sequence[typing.Hashable]
    ] = None,
    inplace: bool = False,
    ignore_index=False
) -> bigframes.dataframe.DataFrame

Remove missing values.

See more: bigframes.pandas.DataFrame.dropna

bigframes.pandas.DataFrame.duplicated

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

Return boolean Series denoting duplicate rows.

See more: bigframes.pandas.DataFrame.duplicated

bigframes.pandas.DataFrame.eq

eq(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get equal to of DataFrame and other, element-wise (binary operator eq).

See more: bigframes.pandas.DataFrame.eq

bigframes.pandas.DataFrame.equals

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

Test whether two objects contain the same elements.

See more: bigframes.pandas.DataFrame.equals

bigframes.pandas.DataFrame.eval

eval(expr: str) -> bigframes.dataframe.DataFrame

Evaluate a string describing operations on DataFrame columns.

See more: bigframes.pandas.DataFrame.eval

bigframes.pandas.DataFrame.expanding

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

Provide expanding window calculations.

See more: bigframes.pandas.DataFrame.expanding

bigframes.pandas.DataFrame.explode

explode(
    column: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    *,
    ignore_index: typing.Optional[bool] = False
) -> bigframes.dataframe.DataFrame

Transform each element of an array to a row, replicating index values.

See more: bigframes.pandas.DataFrame.explode

bigframes.pandas.DataFrame.ffill

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

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

See more: bigframes.pandas.DataFrame.ffill

bigframes.pandas.DataFrame.fillna

fillna(value=None) -> bigframes.dataframe.DataFrame

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.pandas.DataFrame.fillna

bigframes.pandas.DataFrame.filter

filter(
    items: typing.Optional[typing.Iterable] = None,
    like: typing.Optional[str] = None,
    regex: typing.Optional[str] = None,
    axis: int | str | None = None,
) -> bigframes.dataframe.DataFrame

Subset the dataframe rows or columns according to the specified index labels.

See more: bigframes.pandas.DataFrame.filter

bigframes.pandas.DataFrame.first_valid_index

first_valid_index()

API documentation for first_valid_index method.

See more: bigframes.pandas.DataFrame.first_valid_index

bigframes.pandas.DataFrame.floordiv

floordiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get integer division of DataFrame and other, element-wise (binary operator //).

See more: bigframes.pandas.DataFrame.floordiv

bigframes.pandas.DataFrame.from_dict

from_dict(
    data: dict, orient: str = "columns", dtype=None, columns=None
) -> bigframes.dataframe.DataFrame

Construct DataFrame from dict of array-like or dicts.

See more: bigframes.pandas.DataFrame.from_dict

bigframes.pandas.DataFrame.from_records

from_records(
    data,
    index=None,
    exclude=None,
    columns=None,
    coerce_float: bool = False,
    nrows: typing.Optional[int] = None,
) -> bigframes.dataframe.DataFrame

Convert structured or record ndarray to DataFrame.

See more: bigframes.pandas.DataFrame.from_records

bigframes.pandas.DataFrame.ge

ge(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.pandas.DataFrame.ge

bigframes.pandas.DataFrame.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[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    as_index: bool = True,
    dropna: bool = True
) -> bigframes.core.groupby.dataframe_group_by.DataFrameGroupBy

Group DataFrame by columns.

See more: bigframes.pandas.DataFrame.groupby

bigframes.pandas.DataFrame.gt

gt(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get 'greater than' of DataFrame and other, element-wise (binary operator >).

See more: bigframes.pandas.DataFrame.gt

bigframes.pandas.DataFrame.head

head(n: int = 5) -> bigframes.dataframe.DataFrame

Return the first n rows.

See more: bigframes.pandas.DataFrame.head

bigframes.pandas.DataFrame.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.pandas.DataFrame.hist

bigframes.pandas.DataFrame.idxmax

idxmax() -> bigframes.series.Series

Return index of first occurrence of maximum over columns.

See more: bigframes.pandas.DataFrame.idxmax

bigframes.pandas.DataFrame.idxmin

idxmin() -> bigframes.series.Series

Return index of first occurrence of minimum over columns.

See more: bigframes.pandas.DataFrame.idxmin

bigframes.pandas.DataFrame.info

info(
    verbose: typing.Optional[bool] = None,
    buf=None,
    max_cols: typing.Optional[int] = None,
    memory_usage: typing.Optional[bool] = None,
    show_counts: typing.Optional[bool] = None,
)

Print a concise summary of a DataFrame.

See more: bigframes.pandas.DataFrame.info

bigframes.pandas.DataFrame.insert

insert(
    loc: int,
    column: blocks.Label,
    value: SingleItemValue,
    allow_duplicates: bool = False,
)

Insert column into DataFrame at specified location.

See more: bigframes.pandas.DataFrame.insert

bigframes.pandas.DataFrame.interpolate

interpolate(method: str = "linear") -> bigframes.dataframe.DataFrame

Fill NA (NULL in BigQuery) values using an interpolation method.

See more: bigframes.pandas.DataFrame.interpolate

bigframes.pandas.DataFrame.isin

isin(values) -> bigframes.dataframe.DataFrame

Whether each element in the DataFrame is contained in values.

See more: bigframes.pandas.DataFrame.isin

bigframes.pandas.DataFrame.isna

isna() -> bigframes.dataframe.DataFrame

Detect missing (NULL) values.

See more: bigframes.pandas.DataFrame.isna

bigframes.pandas.DataFrame.isnull

isnull() -> bigframes.dataframe.DataFrame

Detect missing (NULL) values.

See more: bigframes.pandas.DataFrame.isnull

bigframes.pandas.DataFrame.items

items()

Iterate over (column name, Series) pairs.

See more: bigframes.pandas.DataFrame.items

bigframes.pandas.DataFrame.iterrows

iterrows() -> typing.Iterable[tuple[typing.Any, pandas.core.series.Series]]

Iterate over DataFrame rows as (index, Series) pairs.

See more: bigframes.pandas.DataFrame.iterrows

bigframes.pandas.DataFrame.itertuples

itertuples(
    index: bool = True, name: typing.Optional[str] = "Pandas"
) -> typing.Iterable[tuple[typing.Any, ...]]

Iterate over DataFrame rows as namedtuples.

See more: bigframes.pandas.DataFrame.itertuples

bigframes.pandas.DataFrame.join

join(
    other: typing.Union[bigframes.dataframe.DataFrame, bigframes.series.Series],
    on: typing.Optional[str] = None,
    how: str = "left",
    lsuffix: str = "",
    rsuffix: str = "",
) -> bigframes.dataframe.DataFrame

Join columns of another DataFrame.

See more: bigframes.pandas.DataFrame.join

bigframes.pandas.DataFrame.keys

keys() -> pandas.core.indexes.base.Index

Get the 'info axis'.

See more: bigframes.pandas.DataFrame.keys

bigframes.pandas.DataFrame.kurt

kurt(*, numeric_only: bool = False)

Return unbiased kurtosis over columns.

See more: bigframes.pandas.DataFrame.kurt

bigframes.pandas.DataFrame.kurtosis

kurtosis(*, numeric_only: bool = False)

Return unbiased kurtosis over columns.

See more: bigframes.pandas.DataFrame.kurtosis

bigframes.pandas.DataFrame.le

le(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.pandas.DataFrame.le

bigframes.pandas.DataFrame.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.pandas.DataFrame.line

bigframes.pandas.DataFrame.lt

lt(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

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

See more: bigframes.pandas.DataFrame.lt

bigframes.pandas.DataFrame.map

map(func, na_action: typing.Optional[str] = None) -> bigframes.dataframe.DataFrame

Apply a function to a Dataframe elementwise.

See more: bigframes.pandas.DataFrame.map

bigframes.pandas.DataFrame.mask

mask(cond, other=None)

Replace values where the condition is False.

See more: bigframes.pandas.DataFrame.mask

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.max

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.mean

bigframes.pandas.DataFrame.median

median(
    *, numeric_only: bool = False, exact: bool = True
) -> bigframes.series.Series

Return the median of the values over colunms.

See more: bigframes.pandas.DataFrame.median

bigframes.pandas.DataFrame.melt

melt(
    id_vars: typing.Optional[typing.Iterable[typing.Hashable]] = None,
    value_vars: typing.Optional[typing.Iterable[typing.Hashable]] = None,
    var_name: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    value_name: typing.Hashable = "value",
)

Unpivot a DataFrame from wide to long format, optionally leaving identifiers set.

See more: bigframes.pandas.DataFrame.melt

bigframes.pandas.DataFrame.memory_usage

memory_usage(index: bool = True)

Return the memory usage of each column in bytes.

See more: bigframes.pandas.DataFrame.memory_usage

bigframes.pandas.DataFrame.merge

merge(
    right: bigframes.dataframe.DataFrame,
    how: typing.Literal["inner", "left", "outer", "right", "cross"] = "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,
    left_index: bool = False,
    right_index: bool = False,
    sort: bool = False,
    suffixes: tuple[str, str] = ("_x", "_y")
) -> bigframes.dataframe.DataFrame

Merge DataFrame objects with a database-style join.

See more: bigframes.pandas.DataFrame.merge

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.min

bigframes.pandas.DataFrame.mod

mod(
    other: int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get modulo of DataFrame and other, element-wise (binary operator %).

See more: bigframes.pandas.DataFrame.mod

bigframes.pandas.DataFrame.mul

mul(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.pandas.DataFrame.mul

bigframes.pandas.DataFrame.multiply

multiply(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.pandas.DataFrame.multiply

bigframes.pandas.DataFrame.ne

ne(other: typing.Any, axis: str | int = "columns") -> bigframes.dataframe.DataFrame

Get not equal to of DataFrame and other, element-wise (binary operator ne).

See more: bigframes.pandas.DataFrame.ne

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.nlargest

bigframes.pandas.DataFrame.notna

notna() -> bigframes.dataframe.DataFrame

Detect existing (non-missing) values.

See more: bigframes.pandas.DataFrame.notna

bigframes.pandas.DataFrame.notnull

notnull() -> bigframes.dataframe.DataFrame

Detect existing (non-missing) values.

See more: bigframes.pandas.DataFrame.notnull

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.nsmallest

bigframes.pandas.DataFrame.nunique

nunique() -> bigframes.series.Series

Count number of distinct elements in each column.

See more: bigframes.pandas.DataFrame.nunique

bigframes.pandas.DataFrame.pct_change

pct_change(periods: int = 1) -> bigframes.dataframe.DataFrame

Fractional change between the current and a prior element.

See more: bigframes.pandas.DataFrame.pct_change

bigframes.pandas.DataFrame.peek

peek(
    n: int = 5, *, force: bool = True, allow_large_results=None
) -> pandas.core.frame.DataFrame

Preview n arbitrary rows from the dataframe.

See more: bigframes.pandas.DataFrame.peek

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.pivot

bigframes.pandas.DataFrame.pivot_table

pivot_table(
    values: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    index: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    columns: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    aggfunc: str = "mean",
) -> bigframes.dataframe.DataFrame

Create a spreadsheet-style pivot table as a DataFrame.

See more: bigframes.pandas.DataFrame.pivot_table

bigframes.pandas.DataFrame.pow

pow(
    other: int | bigframes.series.Series, axis: str | int = "columns"
) -> bigframes.dataframe.DataFrame

Get Exponential power of dataframe and other, element-wise (binary operator **).

See more: bigframes.pandas.DataFrame.pow

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.prod

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.product

bigframes.pandas.DataFrame.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5, *, numeric_only: bool = False
)

Return values at the given quantile over requested axis.

See more: bigframes.pandas.DataFrame.quantile

bigframes.pandas.DataFrame.query

query(expr: str) -> bigframes.dataframe.DataFrame

Query the columns of a DataFrame with a boolean expression.

See more: bigframes.pandas.DataFrame.query

bigframes.pandas.DataFrame.radd

radd(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get addition of DataFrame and other, element-wise (binary operator +).

See more: bigframes.pandas.DataFrame.radd

bigframes.pandas.DataFrame.rank

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

Compute numerical data ranks (1 through n) along axis.

See more: bigframes.pandas.DataFrame.rank

bigframes.pandas.DataFrame.rdiv

rdiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.pandas.DataFrame.rdiv

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.reindex

bigframes.pandas.DataFrame.reindex_like

reindex_like(
    other: bigframes.dataframe.DataFrame, *, validate: typing.Optional[bool] = None
)

Return an object with matching indices as other object.

See more: bigframes.pandas.DataFrame.reindex_like

bigframes.pandas.DataFrame.rename

Rename columns.

See more: bigframes.pandas.DataFrame.rename

bigframes.pandas.DataFrame.rename_axis

Set the name of the axis for the index.

See more: bigframes.pandas.DataFrame.rename_axis

bigframes.pandas.DataFrame.reorder_levels

reorder_levels(
    order: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]],
    axis: int | str = 0,
)

Rearrange index levels using input order.

See more: bigframes.pandas.DataFrame.reorder_levels

bigframes.pandas.DataFrame.replace

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

Replace values given in to_replace with value.

See more: bigframes.pandas.DataFrame.replace

bigframes.pandas.DataFrame.resample

resample(
    rule: str,
    *,
    closed: typing.Optional[typing.Literal["right", "left"]] = None,
    label: typing.Optional[typing.Literal["right", "left"]] = None,
    on: typing.Hashable = None,
    level: typing.Optional[
        typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]]
    ] = None,
    origin: typing.Union[
        pandas._libs.tslibs.timestamps.Timestamp,
        datetime.datetime,
        numpy.datetime64,
        int,
        float,
        str,
        typing.Literal["epoch", "start", "start_day", "end", "end_day"],
    ] = "start_day"
) -> bigframes.core.groupby.dataframe_group_by.DataFrameGroupBy

Resample time-series data.

See more: bigframes.pandas.DataFrame.resample

bigframes.pandas.DataFrame.reset_index

Reset the index.

See more: bigframes.pandas.DataFrame.reset_index

bigframes.pandas.DataFrame.rfloordiv

rfloordiv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get integer division of DataFrame and other, element-wise (binary operator //).

See more: bigframes.pandas.DataFrame.rfloordiv

bigframes.pandas.DataFrame.rmod

rmod(
    other: int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get modulo of DataFrame and other, element-wise (binary operator %).

See more: bigframes.pandas.DataFrame.rmod

bigframes.pandas.DataFrame.rmul

rmul(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get multiplication of DataFrame and other, element-wise (binary operator *).

See more: bigframes.pandas.DataFrame.rmul

bigframes.pandas.DataFrame.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods=None,
    on: str | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Provide rolling window calculations.

See more: bigframes.pandas.DataFrame.rolling

bigframes.pandas.DataFrame.round

round(
    decimals: typing.Union[int, dict[typing.Hashable, int]] = 0,
) -> bigframes.dataframe.DataFrame

Round a DataFrame to a variable number of decimal places.

See more: bigframes.pandas.DataFrame.round

bigframes.pandas.DataFrame.rpow

rpow(
    other: int | bigframes.series.Series, axis: str | int = "columns"
) -> bigframes.dataframe.DataFrame

Get Exponential power of dataframe and other, element-wise (binary operator rpow).

See more: bigframes.pandas.DataFrame.rpow

bigframes.pandas.DataFrame.rsub

rsub(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.pandas.DataFrame.rsub

bigframes.pandas.DataFrame.rtruediv

rtruediv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.pandas.DataFrame.rtruediv

bigframes.pandas.DataFrame.sample

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None,
    sort: typing.Optional[typing.Union[bool, typing.Literal["random"]]] = "random"
) -> bigframes.dataframe.DataFrame

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

See more: bigframes.pandas.DataFrame.sample

bigframes.pandas.DataFrame.scatter

scatter(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    s: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    c: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = None,
    **kwargs
)

Create a scatter plot with varying marker point size and color.

See more: bigframes.pandas.DataFrame.scatter

bigframes.pandas.DataFrame.select_dtypes

select_dtypes(include=None, exclude=None) -> bigframes.dataframe.DataFrame

Return a subset of the DataFrame's columns based on the column dtypes.

See more: bigframes.pandas.DataFrame.select_dtypes

bigframes.pandas.DataFrame.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.

See more: bigframes.pandas.DataFrame.set_index

bigframes.pandas.DataFrame.shift

shift(periods: int = 1) -> bigframes.dataframe.DataFrame

Shift index by desired number of periods.

See more: bigframes.pandas.DataFrame.shift

bigframes.pandas.DataFrame.skew

skew(*, numeric_only: bool = False)

Return unbiased skew over columns.

See more: bigframes.pandas.DataFrame.skew

bigframes.pandas.DataFrame.sort_index

Sort object by labels (along an axis).

See more: bigframes.pandas.DataFrame.sort_index

bigframes.pandas.DataFrame.sort_values

Sort by the values along row axis.

See more: bigframes.pandas.DataFrame.sort_values

bigframes.pandas.DataFrame.stack

stack(level: typing.Union[typing.Hashable, typing.Sequence[typing.Hashable]] = -1)

Stack the prescribed level(s) from columns to index.

See more: bigframes.pandas.DataFrame.stack

bigframes.pandas.DataFrame.std

std(
    axis: typing.Union[str, int] = 0, *, numeric_only: bool = False
) -> bigframes.series.Series

Return sample standard deviation over columns.

See more: bigframes.pandas.DataFrame.std

bigframes.pandas.DataFrame.sub

sub(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.pandas.DataFrame.sub

bigframes.pandas.DataFrame.subtract

subtract(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get subtraction of DataFrame and other, element-wise (binary operator -).

See more: bigframes.pandas.DataFrame.subtract

bigframes.pandas.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.

See more: bigframes.pandas.DataFrame.sum

bigframes.pandas.DataFrame.swaplevel

swaplevel(i: int = -2, j: int = -1, axis: int | str = 0)

Swap levels i and j in a MultiIndex.

See more: bigframes.pandas.DataFrame.swaplevel

bigframes.pandas.DataFrame.tail

tail(n: int = 5) -> bigframes.dataframe.DataFrame

Return the last n rows.

See more: bigframes.pandas.DataFrame.tail

bigframes.pandas.DataFrame.take

take(
    indices: typing.Sequence[int], axis: int | str | None = 0, **kwargs
) -> bigframes.dataframe.DataFrame

Return the elements in the given positional indices along an axis.

See more: bigframes.pandas.DataFrame.take

bigframes.pandas.DataFrame.to_arrow

to_arrow(
    *, ordered: bool = True, allow_large_results: typing.Optional[bool] = None
) -> pyarrow.lib.Table

Write DataFrame to an Arrow table / record batch.

See more: bigframes.pandas.DataFrame.to_arrow

bigframes.pandas.DataFrame.to_csv

to_csv(
    path_or_buf=None,
    sep=",",
    *,
    header: bool = True,
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[str]

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

See more: bigframes.pandas.DataFrame.to_csv

bigframes.pandas.DataFrame.to_dict

to_dict(
    orient: typing.Literal[
        "dict", "list", "series", "split", "tight", "records", "index"
    ] = "dict",
    into: type[dict] = dict,
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> dict | list[dict]

Convert the DataFrame to a dictionary.

See more: bigframes.pandas.DataFrame.to_dict

bigframes.pandas.DataFrame.to_excel

to_excel(
    excel_writer,
    sheet_name: str = "Sheet1",
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> None

Write DataFrame to an Excel sheet.

See more: bigframes.pandas.DataFrame.to_excel

bigframes.pandas.DataFrame.to_gbq

to_gbq(
    destination_table: typing.Optional[str] = None,
    *,
    if_exists: typing.Optional[typing.Literal["fail", "replace", "append"]] = None,
    index: bool = True,
    ordering_id: typing.Optional[str] = None,
    clustering_columns: typing.Union[
        pandas.core.indexes.base.Index, typing.Iterable[typing.Hashable]
    ] = (),
    labels: dict[str, str] = {}
) -> str

Write a DataFrame to a BigQuery table.

See more: bigframes.pandas.DataFrame.to_gbq

bigframes.pandas.DataFrame.to_html

to_html(
    buf=None,
    columns: typing.Optional[typing.Sequence[str]] = None,
    col_space=None,
    header: bool = 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 = ".",
    bold_rows: bool = True,
    classes: str | list | tuple | None = None,
    escape: bool = True,
    notebook: bool = False,
    border: int | None = None,
    table_id: str | None = None,
    render_links: bool = False,
    encoding: str | None = None,
    *,
    allow_large_results: bool | None = None
) -> str

Render a DataFrame as an HTML table.

See more: bigframes.pandas.DataFrame.to_html

bigframes.pandas.DataFrame.to_json

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

Convert the object to a JSON string, written to Cloud Storage.

See more: bigframes.pandas.DataFrame.to_json

bigframes.pandas.DataFrame.to_latex

to_latex(
    buf=None,
    columns: typing.Optional[typing.Sequence] = None,
    header: typing.Union[bool, typing.Sequence[str]] = True,
    index: bool = True,
    *,
    allow_large_results: typing.Optional[bool] = None,
    **kwargs
) -> str | None

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

See more: bigframes.pandas.DataFrame.to_latex

bigframes.pandas.DataFrame.to_markdown

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

Print DataFrame in Markdown-friendly format.

See more: bigframes.pandas.DataFrame.to_markdown

bigframes.pandas.DataFrame.to_numpy

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

Convert the DataFrame to a NumPy array.

See more: bigframes.pandas.DataFrame.to_numpy

bigframes.pandas.DataFrame.to_orc

to_orc(path=None, *, allow_large_results=None, **kwargs) -> bytes | None

Write a DataFrame to the ORC format.

See more: bigframes.pandas.DataFrame.to_orc

bigframes.pandas.DataFrame.to_pandas

Write DataFrame to pandas DataFrame.

See more: bigframes.pandas.DataFrame.to_pandas

bigframes.pandas.DataFrame.to_pandas_batches

to_pandas_batches(
    page_size: typing.Optional[int] = None,
    max_results: typing.Optional[int] = None,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Iterable[pandas.core.frame.DataFrame]

Stream DataFrame results to an iterable of pandas DataFrame.

See more: bigframes.pandas.DataFrame.to_pandas_batches

bigframes.pandas.DataFrame.to_parquet

to_parquet(
    path=None,
    *,
    compression: typing.Optional[typing.Literal["snappy", "gzip"]] = "snappy",
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[bytes]

Write a DataFrame to the binary Parquet format.

See more: bigframes.pandas.DataFrame.to_parquet

bigframes.pandas.DataFrame.to_pickle

to_pickle(path, *, allow_large_results=None, **kwargs) -> None

Pickle (serialize) object to file.

See more: bigframes.pandas.DataFrame.to_pickle

bigframes.pandas.DataFrame.to_records

to_records(
    index: bool = True,
    column_dtypes=None,
    index_dtypes=None,
    *,
    allow_large_results=None
) -> numpy.rec.recarray

Convert DataFrame to a NumPy record array.

See more: bigframes.pandas.DataFrame.to_records

bigframes.pandas.DataFrame.to_string

to_string(
    buf=None,
    columns: typing.Optional[typing.Sequence[str]] = None,
    col_space=None,
    header: typing.Union[bool, typing.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,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> str | None

Render a DataFrame to a console-friendly tabular output.

See more: bigframes.pandas.DataFrame.to_string

bigframes.pandas.DataFrame.transpose

transpose() -> bigframes.dataframe.DataFrame

Transpose index and columns.

See more: bigframes.pandas.DataFrame.transpose

bigframes.pandas.DataFrame.truediv

truediv(
    other: float | int | bigframes.series.Series | bigframes.dataframe.DataFrame,
    axis: str | int = "columns",
) -> bigframes.dataframe.DataFrame

Get floating division of DataFrame and other, element-wise (binary operator /).

See more: bigframes.pandas.DataFrame.truediv

bigframes.pandas.DataFrame.unstack

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

Pivot a level of the (necessarily hierarchical) index labels.

See more: bigframes.pandas.DataFrame.unstack

bigframes.pandas.DataFrame.update

update(other, join: str = "left", overwrite=True, filter_func=None)

Modify in place using non-NA values from another DataFrame.

See more: bigframes.pandas.DataFrame.update

bigframes.pandas.DataFrame.value_counts

value_counts(
    subset: 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.

See more: bigframes.pandas.DataFrame.value_counts

bigframes.pandas.DataFrame.var

var(
    axis: typing.Union[str, int] = 0, *, numeric_only: bool = False
) -> bigframes.series.Series

Return unbiased variance over requested axis.

See more: bigframes.pandas.DataFrame.var

bigframes.pandas.DataFrame.where

where(cond, other=None)

Replace values where the condition is False.

See more: bigframes.pandas.DataFrame.where

bigframes.pandas.Index.setitem

__setitem__(key, value) -> None

Index objects are immutable.

See more: bigframes.pandas.Index.setitem

bigframes.pandas.Index.all

all() -> bool

Return whether all elements are Truthy.

See more: bigframes.pandas.Index.all

bigframes.pandas.Index.any

any() -> bool

Return whether any element is Truthy.

See more: bigframes.pandas.Index.any

bigframes.pandas.Index.argmax

argmax() -> int

Return int position of the largest value in the Series.

See more: bigframes.pandas.Index.argmax

bigframes.pandas.Index.argmin

argmin() -> int

Return int position of the smallest value in the series.

See more: bigframes.pandas.Index.argmin

bigframes.pandas.Index.astype

astype(
    dtype, *, errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.core.indexes.base.Index

Create an Index with values cast to dtypes.

See more: bigframes.pandas.Index.astype

bigframes.pandas.Index.copy

copy(name: typing.Optional[typing.Hashable] = None)

Make a copy of this object.

See more: bigframes.pandas.Index.copy

bigframes.pandas.Index.drop

drop(labels: typing.Any) -> bigframes.core.indexes.base.Index

Make new Index with passed list of labels deleted.

See more: bigframes.pandas.Index.drop

bigframes.pandas.Index.drop_duplicates

drop_duplicates(*, keep: __builtins__.str = "first") -> Index

Return Index with duplicate values removed.

See more: bigframes.pandas.Index.drop_duplicates

bigframes.pandas.Index.dropna

dropna(
    how: typing.Literal["all", "any"] = "any",
) -> bigframes.core.indexes.base.Index

Return Index without NA/NaN values.

See more: bigframes.pandas.Index.dropna

bigframes.pandas.Index.fillna

fillna(value=None) -> bigframes.core.indexes.base.Index

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.pandas.Index.fillna

bigframes.pandas.Index.from_frame

from_frame(
    frame: typing.Union[bigframes.series.Series, bigframes.dataframe.DataFrame],
) -> bigframes.core.indexes.base.Index

Make a MultiIndex from a DataFrame.

See more: bigframes.pandas.Index.from_frame

bigframes.pandas.Index.get_level_values

get_level_values(level) -> bigframes.core.indexes.base.Index

Return an Index of values for requested level.

See more: bigframes.pandas.Index.get_level_values

bigframes.pandas.Index.get_loc

get_loc(key) -> typing.Union[int, slice, bigframes.series.Series]

Get integer location, slice or boolean mask for requested label.

See more: bigframes.pandas.Index.get_loc

bigframes.pandas.Index.isin

isin(values) -> bigframes.core.indexes.base.Index

Return a boolean array where the index values are in values.

See more: bigframes.pandas.Index.isin

bigframes.pandas.Index.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.pandas.Index.item

bigframes.pandas.Index.max

max() -> typing.Any

Return the maximum value of the Index.

See more: bigframes.pandas.Index.max

bigframes.pandas.Index.min

min() -> typing.Any

Return the minimum value of the Index.

See more: bigframes.pandas.Index.min

bigframes.pandas.Index.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.pandas.Index.nunique

bigframes.pandas.Index.rename

Alter Index or MultiIndex name.

See more: bigframes.pandas.Index.rename

bigframes.pandas.Index.sort_values

sort_values(
    *,
    inplace: bool = False,
    ascending: bool = True,
    na_position: __builtins__.str = "last"
) -> Index

Return a sorted copy of the index.

See more: bigframes.pandas.Index.sort_values

bigframes.pandas.Index.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

API documentation for to_list method.

See more: bigframes.pandas.Index.to_list

bigframes.pandas.Index.to_numpy

to_numpy(dtype=None, *, allow_large_results=None, **kwargs) -> numpy.ndarray

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

See more: bigframes.pandas.Index.to_numpy

bigframes.pandas.Index.to_pandas

Gets the Index as a pandas Index.

See more: bigframes.pandas.Index.to_pandas

bigframes.pandas.Index.to_series

to_series(
    index: typing.Optional[bigframes.core.indexes.base.Index] = None,
    name: typing.Optional[typing.Hashable] = None,
) -> bigframes.series.Series

Create a Series with both index and values equal to the index keys.

See more: bigframes.pandas.Index.to_series

bigframes.pandas.Index.transpose

transpose() -> bigframes.core.indexes.base.Index

Return the transpose, which is by definition self.

See more: bigframes.pandas.Index.transpose

bigframes.pandas.Index.unique

unique(
    level: typing.Optional[typing.Union[typing.Hashable, int]] = None,
) -> bigframes.core.indexes.base.Index

Returns unique values in the index.

See more: bigframes.pandas.Index.unique

bigframes.pandas.Index.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.pandas.Index.value_counts

bigframes.pandas.MultiIndex.from_arrays

from_arrays(
    arrays,
    sortorder: int | None = None,
    names=None,
    *,
    session: Optional[bigframes.session.Session] = None
) -> MultiIndex

Convert arrays to MultiIndex.

See more: bigframes.pandas.MultiIndex.from_arrays

bigframes.pandas.MultiIndex.from_tuples

from_tuples(
    tuples: Iterable[tuple[Hashable, ...]],
    sortorder: int | None = None,
    names: Sequence[Hashable] | Hashable | None = None,
    *,
    session: Optional[bigframes.session.Session] = None
) -> MultiIndex

Convert list of tuples to MultiIndex.

See more: bigframes.pandas.MultiIndex.from_tuples

bigframes.pandas.NamedAgg

NamedAgg(column, aggfunc)

Create new instance of NamedAgg(column, aggfunc).

See more: bigframes.pandas.NamedAgg

bigframes.pandas.Series.abs

__abs__() -> bigframes.series.Series

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

See more: bigframes.pandas.Series.abs

bigframes.pandas.Series.add

__add__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.pandas.Series.add

bigframes.pandas.Series.and

__and__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.pandas.Series.and

bigframes.pandas.Series.array

__array__(dtype=None, copy: typing.Optional[bool] = None) -> numpy.ndarray

Returns the values as NumPy array.

See more: bigframes.pandas.Series.array

bigframes.pandas.Series.__array_ufunc__

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

Used to support numpy ufuncs.

See more: bigframes.pandas.Series.array_ufunc

bigframes.pandas.Series.floordiv

__floordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of Series by other, using arithmetic operator //.

See more: bigframes.pandas.Series.floordiv

bigframes.pandas.Series.getitem

__getitem__(indexer)

Gets the specified index from the Series.

See more: bigframes.pandas.Series.getitem

bigframes.pandas.Series.invert

__invert__() -> bigframes.series.Series

Returns the logical inversion (binary NOT) of the Series, element-wise using operator ````.

See more: bigframes.pandas.Series.invert

bigframes.pandas.Series.len

__len__()

Returns number of values in the Series, serves len operator.

See more: bigframes.pandas.Series.len

bigframes.pandas.Series.matmul

__matmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.pandas.Series.matmul

bigframes.pandas.Series.mod

__mod__(other) -> bigframes.series.Series

Get modulo of Series with other, element-wise, using operator %.

See more: bigframes.pandas.Series.mod

bigframes.pandas.Series.mul

__mul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of Series with other, element-wise, using operator *.

See more: bigframes.pandas.Series.mul

bigframes.pandas.Series.or

__or__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.pandas.Series.or

bigframes.pandas.Series.pow

__pow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of Series with other, element-wise, using operator **.

See more: bigframes.pandas.Series.pow

bigframes.pandas.Series.radd

__radd__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.pandas.Series.radd

bigframes.pandas.Series.rand

__rand__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.pandas.Series.rand

bigframes.pandas.Series.rfloordiv

__rfloordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of other by Series, using arithmetic operator //.

See more: bigframes.pandas.Series.rfloordiv

bigframes.pandas.Series.rmatmul

__rmatmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.pandas.Series.rmatmul

bigframes.pandas.Series.rmod

__rmod__(other) -> bigframes.series.Series

Get modulo of other with Series, element-wise, using operator %.

See more: bigframes.pandas.Series.rmod

bigframes.pandas.Series.rmul

__rmul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of other with Series, element-wise, using operator *.

See more: bigframes.pandas.Series.rmul

bigframes.pandas.Series.ror

__ror__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.pandas.Series.ror

bigframes.pandas.Series.rpow

__rpow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of other with Series, element-wise, using operator **.

See more: bigframes.pandas.Series.rpow

bigframes.pandas.Series.rsub

__rsub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of Series from other, element-wise, using operator -.

See more: bigframes.pandas.Series.rsub

bigframes.pandas.Series.rtruediv

__rtruediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of other by Series, element-wise, using operator /.

See more: bigframes.pandas.Series.rtruediv

bigframes.pandas.Series.setitem

__setitem__(key, value) -> None

Set item using direct assignment, delegating to .loc indexer.

See more: bigframes.pandas.Series.setitem

bigframes.pandas.Series.sub

__sub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of other from Series, element-wise, using operator -.

See more: bigframes.pandas.Series.sub

bigframes.pandas.Series.truediv

__truediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of Series by other, element-wise, using operator /.

See more: bigframes.pandas.Series.truediv

bigframes.pandas.Series.abs

abs() -> bigframes.series.Series

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

See more: bigframes.pandas.Series.abs

bigframes.pandas.Series.add

add(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.add

bigframes.pandas.Series.add_prefix

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

Prefix labels with string prefix.

See more: bigframes.pandas.Series.add_prefix

bigframes.pandas.Series.add_suffix

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

Suffix labels with string suffix.

See more: bigframes.pandas.Series.add_suffix

bigframes.pandas.Series.agg

agg(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.pandas.Series.agg

bigframes.pandas.Series.aggregate

aggregate(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.pandas.Series.aggregate

bigframes.pandas.Series.all

all() -> bool

Return whether all elements are True, potentially over an axis.

See more: bigframes.pandas.Series.all

bigframes.pandas.Series.any

any() -> bool

Return whether any element is True, potentially over an axis.

See more: bigframes.pandas.Series.any

bigframes.pandas.Series.apply

apply(
    func,
    by_row: typing.Union[typing.Literal["compat"], bool] = "compat",
    *,
    args: typing.Tuple = ()
) -> bigframes.series.Series

Invoke function on values of a Series.

See more: bigframes.pandas.Series.apply

bigframes.pandas.Series.area

area(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    stacked: bool = True,
    **kwargs
)

Draw a stacked area plot.

See more: bigframes.pandas.Series.area

bigframes.pandas.Series.argmax

argmax() -> int

Return int position of the largest value in the series.

See more: bigframes.pandas.Series.argmax

bigframes.pandas.Series.argmin

argmin() -> int

Return int position of the smallest value in the Series.

See more: bigframes.pandas.Series.argmin

bigframes.pandas.Series.astype

astype(
    dtype: typing.Union[
        typing.Literal[
            "boolean",
            "Float64",
            "Int64",
            "int64[pyarrow]",
            "string",
            "string[pyarrow]",
            "timestamp[us, tz=UTC][pyarrow]",
            "timestamp[us][pyarrow]",
            "date32[day][pyarrow]",
            "time64[us][pyarrow]",
            "decimal128(38, 9)[pyarrow]",
            "decimal256(76, 38)[pyarrow]",
            "binary[pyarrow]",
            "duration[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,
        geopandas.array.GeometryDtype,
    ],
    *,
    errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.series.Series

Cast a pandas object to a specified dtype dtype.

See more: bigframes.pandas.Series.astype

bigframes.pandas.Series.autocorr

autocorr(lag: int = 1) -> float

Compute the lag-N autocorrelation.

See more: bigframes.pandas.Series.autocorr

bigframes.pandas.Series.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.pandas.Series.bar

bigframes.pandas.Series.between

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

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

See more: bigframes.pandas.Series.between

bigframes.pandas.Series.bfill

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

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

See more: bigframes.pandas.Series.bfill

bigframes.pandas.Series.cache

cache()

Materializes the Series to a temporary table.

See more: bigframes.pandas.Series.cache

bigframes.pandas.Series.case_when

case_when(caselist) -> bigframes.series.Series

Replace values where the conditions are True.

See more: bigframes.pandas.Series.case_when

bigframes.pandas.Series.clip

clip(lower=None, upper=None)

Trim values at input threshold(s).

See more: bigframes.pandas.Series.clip

bigframes.pandas.Series.combine

combine(other, func) -> bigframes.series.Series

Combine the Series with a Series or scalar according to func.

See more: bigframes.pandas.Series.combine

bigframes.pandas.Series.combine_first

combine_first(other: bigframes.series.Series) -> bigframes.series.Series

Update null elements with value in the same location in 'other'.

See more: bigframes.pandas.Series.combine_first

bigframes.pandas.Series.copy

copy() -> bigframes.series.Series

Make a copy of this object's indices and data.

See more: bigframes.pandas.Series.copy

bigframes.pandas.Series.corr

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

Compute the correlation with the other Series.

See more: bigframes.pandas.Series.corr

bigframes.pandas.Series.count

count() -> int

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

See more: bigframes.pandas.Series.count

bigframes.pandas.Series.cov

cov(other: bigframes.series.Series) -> float

Compute covariance with Series, excluding missing values.

See more: bigframes.pandas.Series.cov

bigframes.pandas.Series.cummax

cummax() -> bigframes.series.Series

Return cumulative maximum over a DataFrame or Series axis.

See more: bigframes.pandas.Series.cummax

bigframes.pandas.Series.cummin

cummin() -> bigframes.series.Series

Return cumulative minimum over a DataFrame or Series axis.

See more: bigframes.pandas.Series.cummin

bigframes.pandas.Series.cumprod

cumprod() -> bigframes.series.Series

Return cumulative product over a DataFrame or Series axis.

See more: bigframes.pandas.Series.cumprod

bigframes.pandas.Series.cumsum

cumsum() -> bigframes.series.Series

Return cumulative sum over a DataFrame or Series axis.

See more: bigframes.pandas.Series.cumsum

bigframes.pandas.Series.describe

describe() -> bigframes.series.Series

Generate descriptive statistics.

See more: bigframes.pandas.Series.describe

bigframes.pandas.Series.diff

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

First discrete difference of element.

See more: bigframes.pandas.Series.diff

bigframes.pandas.Series.div

div(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.div

bigframes.pandas.Series.divide

divide(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.divide

bigframes.pandas.Series.divmod

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

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

See more: bigframes.pandas.Series.divmod

bigframes.pandas.Series.dot

dot(other)

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

See more: bigframes.pandas.Series.dot

bigframes.pandas.Series.drop

drop(
    labels: typing.Any = None,
    *,
    axis: typing.Union[int, str] = 0,
    index: typing.Any = None,
    columns: 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.

See more: bigframes.pandas.Series.drop

bigframes.pandas.Series.drop_duplicates

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

Return Series with duplicate values removed.

See more: bigframes.pandas.Series.drop_duplicates

bigframes.pandas.Series.droplevel

droplevel(
    level: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

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

See more: bigframes.pandas.Series.droplevel

bigframes.pandas.Series.dropna

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.

See more: bigframes.pandas.Series.dropna

bigframes.pandas.Series.duplicated

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

Indicate duplicate Series values.

See more: bigframes.pandas.Series.duplicated

bigframes.pandas.Series.eq

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

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

See more: bigframes.pandas.Series.eq

bigframes.pandas.Series.equals

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

Test whether two objects contain the same elements.

See more: bigframes.pandas.Series.equals

bigframes.pandas.Series.expanding

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

Provide expanding window calculations.

See more: bigframes.pandas.Series.expanding

bigframes.pandas.Series.explode

explode(*, ignore_index: typing.Optional[bool] = False) -> bigframes.series.Series

Transform each element of a list-like to a row.

See more: bigframes.pandas.Series.explode

bigframes.pandas.Series.ffill

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

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

See more: bigframes.pandas.Series.ffill

bigframes.pandas.Series.fillna

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

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.pandas.Series.fillna

bigframes.pandas.Series.filter

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.

See more: bigframes.pandas.Series.filter

bigframes.pandas.Series.floordiv

floordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.floordiv

bigframes.pandas.Series.ge

ge(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.ge

bigframes.pandas.Series.groupby

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

Group Series using a mapper or by a Series of columns.

See more: bigframes.pandas.Series.groupby

bigframes.pandas.Series.gt

gt(other) -> bigframes.series.Series

Return Greater than of series and other, element-wise (binary operator gt).

See more: bigframes.pandas.Series.gt

bigframes.pandas.Series.head

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

Return the first n rows.

See more: bigframes.pandas.Series.head

bigframes.pandas.Series.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.pandas.Series.hist

bigframes.pandas.Series.idxmax

idxmax() -> typing.Hashable

Return the row label of the maximum value.

See more: bigframes.pandas.Series.idxmax

bigframes.pandas.Series.idxmin

idxmin() -> typing.Hashable

Return the row label of the minimum value.

See more: bigframes.pandas.Series.idxmin

bigframes.pandas.Series.interpolate

interpolate(method: str = "linear") -> bigframes.series.Series

Fill NaN values using an interpolation method.

See more: bigframes.pandas.Series.interpolate

bigframes.pandas.Series.isin

isin(values) -> bigframes.series.Series

Whether elements in Series are contained in values.

See more: bigframes.pandas.Series.isin

bigframes.pandas.Series.isna

isna() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.pandas.Series.isna

bigframes.pandas.Series.isnull

isnull() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.pandas.Series.isnull

bigframes.pandas.Series.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.pandas.Series.item

bigframes.pandas.Series.items

items()

Lazily iterate over (index, value) tuples.

See more: bigframes.pandas.Series.items

bigframes.pandas.Series.keys

keys() -> bigframes.core.indexes.base.Index

Return alias for index.

See more: bigframes.pandas.Series.keys

bigframes.pandas.Series.kurt

kurt()

Return unbiased kurtosis over requested axis.

See more: bigframes.pandas.Series.kurt

bigframes.pandas.Series.kurtosis

kurtosis()

Return unbiased kurtosis over requested axis.

See more: bigframes.pandas.Series.kurtosis

bigframes.pandas.Series.le

le(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.le

bigframes.pandas.Series.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.pandas.Series.line

bigframes.pandas.Series.lt

lt(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.lt

bigframes.pandas.Series.map

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

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

See more: bigframes.pandas.Series.map

bigframes.pandas.Series.mask

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

Replace values where the condition is True.

See more: bigframes.pandas.Series.mask

bigframes.pandas.Series.max

max() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.pandas.Series.max

bigframes.pandas.Series.mean

mean() -> float

Return the mean of the values over the requested axis.

See more: bigframes.pandas.Series.mean

bigframes.pandas.Series.median

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

Return the median of the values over the requested axis.

See more: bigframes.pandas.Series.median

bigframes.pandas.Series.min

min() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.pandas.Series.min

bigframes.pandas.Series.mod

mod(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.mod

bigframes.pandas.Series.mode

mode() -> bigframes.series.Series

Return the mode(s) of the Series.

See more: bigframes.pandas.Series.mode

bigframes.pandas.Series.mul

mul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.mul

bigframes.pandas.Series.multiply

multiply(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.multiply

bigframes.pandas.Series.ne

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

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

See more: bigframes.pandas.Series.ne

bigframes.pandas.Series.nlargest

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

Return the largest n elements.

See more: bigframes.pandas.Series.nlargest

bigframes.pandas.Series.notna

notna() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.pandas.Series.notna

bigframes.pandas.Series.notnull

notnull() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.pandas.Series.notnull

bigframes.pandas.Series.nsmallest

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

Return the smallest n elements.

See more: bigframes.pandas.Series.nsmallest

bigframes.pandas.Series.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.pandas.Series.nunique

bigframes.pandas.Series.pad

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

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

See more: bigframes.pandas.Series.pad

bigframes.pandas.Series.pct_change

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

Fractional change between the current and a prior element.

See more: bigframes.pandas.Series.pct_change

bigframes.pandas.Series.peek

peek(
    n: int = 5, *, force: bool = True, allow_large_results=None
) -> pandas.core.series.Series

Preview n arbitrary elements from the series without guarantees about row selection or ordering.

See more: bigframes.pandas.Series.peek

bigframes.pandas.Series.pow

pow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.pow

bigframes.pandas.Series.prod

prod() -> float

Return the product of the values over the requested axis.

See more: bigframes.pandas.Series.prod

bigframes.pandas.Series.product

product() -> float

Return the product of the values over the requested axis.

See more: bigframes.pandas.Series.product

bigframes.pandas.Series.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5,
) -> typing.Union[bigframes.series.Series, float]

Return value at the given quantile.

See more: bigframes.pandas.Series.quantile

bigframes.pandas.Series.radd

radd(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.radd

bigframes.pandas.Series.rank

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

Compute numerical data ranks (1 through n) along axis.

See more: bigframes.pandas.Series.rank

bigframes.pandas.Series.rdiv

rdiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rdiv

bigframes.pandas.Series.rdivmod

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

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

See more: bigframes.pandas.Series.rdivmod

bigframes.pandas.Series.reindex

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

Conform Series to new index with optional filling logic.

See more: bigframes.pandas.Series.reindex

bigframes.pandas.Series.reindex_like

reindex_like(
    other: bigframes.series.Series, *, validate: typing.Optional[bool] = None
)

Return an object with matching indices as other object.

See more: bigframes.pandas.Series.reindex_like

bigframes.pandas.Series.rename

Alter Series index labels or name.

See more: bigframes.pandas.Series.rename

bigframes.pandas.Series.rename_axis

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

See more: bigframes.pandas.Series.rename_axis

bigframes.pandas.Series.reorder_levels

reorder_levels(
    order: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

Rearrange index levels using input order.

See more: bigframes.pandas.Series.reorder_levels

bigframes.pandas.Series.replace

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

Replace values given in to_replace with value.

See more: bigframes.pandas.Series.replace

bigframes.pandas.Series.resample

resample(
    rule: str,
    *,
    closed: typing.Optional[typing.Literal["right", "left"]] = None,
    label: typing.Optional[typing.Literal["right", "left"]] = None,
    level: typing.Optional[
        typing.Union[str, int, typing.Sequence[typing.Union[str, int]]]
    ] = None,
    origin: typing.Union[
        pandas._libs.tslibs.timestamps.Timestamp,
        datetime.datetime,
        numpy.datetime64,
        int,
        float,
        str,
        typing.Literal["epoch", "start", "start_day", "end", "end_day"],
    ] = "start_day"
) -> bigframes.core.groupby.series_group_by.SeriesGroupBy

Resample time-series data.

See more: bigframes.pandas.Series.resample

bigframes.pandas.Series.reset_index

Generate a new DataFrame or Series with the index reset.

See more: bigframes.pandas.Series.reset_index

bigframes.pandas.Series.rfloordiv

rfloordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rfloordiv

bigframes.pandas.Series.rmod

rmod(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rmod

bigframes.pandas.Series.rmul

rmul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rmul

bigframes.pandas.Series.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods: int | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Provide rolling window calculations.

See more: bigframes.pandas.Series.rolling

bigframes.pandas.Series.round

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

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

See more: bigframes.pandas.Series.round

bigframes.pandas.Series.rpow

rpow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rpow

bigframes.pandas.Series.rsub

rsub(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rsub

bigframes.pandas.Series.rtruediv

rtruediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.rtruediv

bigframes.pandas.Series.sample

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None,
    sort: typing.Optional[typing.Union[bool, typing.Literal["random"]]] = "random"
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.sample

bigframes.pandas.Series.shift

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

Shift index by desired number of periods.

See more: bigframes.pandas.Series.shift

bigframes.pandas.Series.skew

skew()

Return unbiased skew over requested axis.

See more: bigframes.pandas.Series.skew

bigframes.pandas.Series.sort_index

Sort Series by index labels.

See more: bigframes.pandas.Series.sort_index

bigframes.pandas.Series.sort_values

Sort by the values.

See more: bigframes.pandas.Series.sort_values

bigframes.pandas.Series.std

std() -> float

Return sample standard deviation over requested axis.

See more: bigframes.pandas.Series.std

bigframes.pandas.Series.sub

sub(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.sub

bigframes.pandas.Series.subtract

subtract(other) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.subtract

bigframes.pandas.Series.sum

sum() -> float

Return the sum of the values over the requested axis.

See more: bigframes.pandas.Series.sum

bigframes.pandas.Series.swaplevel

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

Swap levels i and j in a MultiIndex.

See more: bigframes.pandas.Series.swaplevel

bigframes.pandas.Series.tail

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

Return the last n rows.

See more: bigframes.pandas.Series.tail

bigframes.pandas.Series.take

take(
    indices: typing.Sequence[int], axis: int | str | None = 0, **kwargs
) -> bigframes.series.Series

Return the elements in the given positional indices along an axis.

See more: bigframes.pandas.Series.take

bigframes.pandas.Series.to_csv

to_csv(
    path_or_buf=None,
    sep=",",
    *,
    header: bool = True,
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[str]

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

See more: bigframes.pandas.Series.to_csv

bigframes.pandas.Series.to_dict

to_dict(
    into: type[dict] = dict, *, allow_large_results: typing.Optional[bool] = None
) -> typing.Mapping

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

See more: bigframes.pandas.Series.to_dict

bigframes.pandas.Series.to_excel

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

Write Series to an Excel sheet.

See more: bigframes.pandas.Series.to_excel

bigframes.pandas.Series.to_frame

to_frame(name: typing.Hashable = None) -> bigframes.dataframe.DataFrame

Convert Series to DataFrame.

See more: bigframes.pandas.Series.to_frame

bigframes.pandas.Series.to_json

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

Convert the object to a JSON string, written to Cloud Storage.

See more: bigframes.pandas.Series.to_json

bigframes.pandas.Series.to_latex

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

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

See more: bigframes.pandas.Series.to_latex

bigframes.pandas.Series.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.pandas.Series.to_list

bigframes.pandas.Series.to_markdown

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

Print Series in Markdown-friendly format.

See more: bigframes.pandas.Series.to_markdown

bigframes.pandas.Series.to_numpy

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

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

See more: bigframes.pandas.Series.to_numpy

bigframes.pandas.Series.to_pandas

to_pandas(
    max_download_size: typing.Optional[int] = None,
    sampling_method: typing.Optional[str] = None,
    random_state: typing.Optional[int] = None,
    *,
    ordered: bool = True,
    dry_run: bool = False,
    allow_large_results: typing.Optional[bool] = None
) -> pandas.core.series.Series

Writes Series to pandas Series.

See more: bigframes.pandas.Series.to_pandas

bigframes.pandas.Series.to_pandas_batches

to_pandas_batches(
    page_size: typing.Optional[int] = None,
    max_results: typing.Optional[int] = None,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Iterable[pandas.core.series.Series]

Stream Series results to an iterable of pandas Series.

See more: bigframes.pandas.Series.to_pandas_batches

bigframes.pandas.Series.to_pickle

to_pickle(path, *, allow_large_results=None, **kwargs) -> None

Pickle (serialize) object to file.

See more: bigframes.pandas.Series.to_pickle

bigframes.pandas.Series.to_string

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,
    *,
    allow_large_results=None
) -> typing.Optional[str]

Render a string representation of the Series.

See more: bigframes.pandas.Series.to_string

bigframes.pandas.Series.to_xarray

to_xarray(*, allow_large_results: typing.Optional[bool] = None)

Return an xarray object from the pandas object.

See more: bigframes.pandas.Series.to_xarray

bigframes.pandas.Series.tolist

tolist(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.pandas.Series.tolist

bigframes.pandas.Series.transpose

transpose() -> bigframes.series.Series

Return the transpose, which is by definition self.

See more: bigframes.pandas.Series.transpose

bigframes.pandas.Series.truediv

truediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.pandas.Series.truediv

bigframes.pandas.Series.unique

unique(keep_order=True) -> bigframes.series.Series

Return unique values of Series object.

See more: bigframes.pandas.Series.unique

bigframes.pandas.Series.unstack

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

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

See more: bigframes.pandas.Series.unstack

bigframes.pandas.Series.update

update(
    other: typing.Union[bigframes.series.Series, typing.Sequence, typing.Mapping],
) -> None

Modify Series in place using values from passed Series.

See more: bigframes.pandas.Series.update

bigframes.pandas.Series.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.pandas.Series.value_counts

bigframes.pandas.Series.var

var() -> float

Return unbiased variance over requested axis.

See more: bigframes.pandas.Series.var

bigframes.pandas.Series.where

where(cond, other=None)

Replace values where the condition is False.

See more: bigframes.pandas.Series.where

bigframes.pandas.StringDtype.__from_arrow__

__from_arrow__(array: pyarrow.Array | pyarrow.ChunkedArray) -> BaseStringArray

Construct StringArray from pyarrow Array/ChunkedArray.

See more: bigframes.pandas.StringDtype.from_arrow

bigframes.pandas.StringDtype.construct_array_type

construct_array_type() -> type_t[BaseStringArray]

Return the array type associated with this dtype.

See more: bigframes.pandas.StringDtype.construct_array_type

bigframes.pandas.StringDtype.construct_from_string

construct_from_string(string) -> Self

Construct a StringDtype from a string.

See more: bigframes.pandas.StringDtype.construct_from_string

bigframes.series.Series.abs

__abs__() -> bigframes.series.Series

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

See more: bigframes.series.Series.abs

bigframes.series.Series.add

__add__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.series.Series.add

bigframes.series.Series.and

__and__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.series.Series.and

bigframes.series.Series.array

__array__(dtype=None, copy: typing.Optional[bool] = None) -> numpy.ndarray

Returns the values as NumPy array.

See more: bigframes.series.Series.array

bigframes.series.Series.__array_ufunc__

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

Used to support numpy ufuncs.

See more: bigframes.series.Series.array_ufunc

bigframes.series.Series.bool

__bool__()

Returns the truth value of the object.

See more: bigframes.series.Series.bool

bigframes.series.Series.floordiv

__floordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of Series by other, using arithmetic operator //.

See more: bigframes.series.Series.floordiv

bigframes.series.Series.getitem

__getitem__(indexer)

Gets the specified index from the Series.

See more: bigframes.series.Series.getitem

bigframes.series.Series.invert

__invert__() -> bigframes.series.Series

Returns the logical inversion (binary NOT) of the Series, element-wise using operator ````.

See more: bigframes.series.Series.invert

bigframes.series.Series.len

__len__()

Returns number of values in the Series, serves len operator.

See more: bigframes.series.Series.len

bigframes.series.Series.matmul

__matmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.series.Series.matmul

bigframes.series.Series.mod

__mod__(other) -> bigframes.series.Series

Get modulo of Series with other, element-wise, using operator %.

See more: bigframes.series.Series.mod

bigframes.series.Series.mul

__mul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of Series with other, element-wise, using operator *.

See more: bigframes.series.Series.mul

bigframes.series.Series.nonzero

__nonzero__()

Returns the truth value of the object.

See more: bigframes.series.Series.nonzero

bigframes.series.Series.or

__or__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.series.Series.or

bigframes.series.Series.pow

__pow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of Series with other, element-wise, using operator **.

See more: bigframes.series.Series.pow

bigframes.series.Series.radd

__radd__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get addition of Series and other, element-wise, using operator +.

See more: bigframes.series.Series.radd

bigframes.series.Series.rand

__rand__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise AND of Series and other, element-wise, using operator &.

See more: bigframes.series.Series.rand

bigframes.series.Series.rfloordiv

__rfloordiv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get integer division of other by Series, using arithmetic operator //.

See more: bigframes.series.Series.rfloordiv

bigframes.series.Series.rmatmul

__rmatmul__(other)

Matrix multiplication using binary @ operator.

See more: bigframes.series.Series.rmatmul

bigframes.series.Series.rmod

__rmod__(other) -> bigframes.series.Series

Get modulo of other with Series, element-wise, using operator %.

See more: bigframes.series.Series.rmod

bigframes.series.Series.rmul

__rmul__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get multiplication of other with Series, element-wise, using operator *.

See more: bigframes.series.Series.rmul

bigframes.series.Series.ror

__ror__(other: bool | int | bigframes.series.Series) -> bigframes.series.Series

Get bitwise XOR of Series and other, element-wise, using operator ^.

See more: bigframes.series.Series.ror

bigframes.series.Series.rpow

__rpow__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get exponentiation of other with Series, element-wise, using operator **.

See more: bigframes.series.Series.rpow

bigframes.series.Series.rsub

__rsub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of Series from other, element-wise, using operator -.

See more: bigframes.series.Series.rsub

bigframes.series.Series.rtruediv

__rtruediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of other by Series, element-wise, using operator /.

See more: bigframes.series.Series.rtruediv

bigframes.series.Series.setitem

__setitem__(key, value) -> None

Set item using direct assignment, delegating to .loc indexer.

See more: bigframes.series.Series.setitem

bigframes.series.Series.sub

__sub__(other: float | int | bigframes.series.Series) -> bigframes.series.Series

Get subtraction of other from Series, element-wise, using operator -.

See more: bigframes.series.Series.sub

bigframes.series.Series.truediv

__truediv__(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

Get division of Series by other, element-wise, using operator /.

See more: bigframes.series.Series.truediv

bigframes.series.Series.abs

abs() -> bigframes.series.Series

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

See more: bigframes.series.Series.abs

bigframes.series.Series.add

add(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.add

bigframes.series.Series.add_prefix

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

Prefix labels with string prefix.

See more: bigframes.series.Series.add_prefix

bigframes.series.Series.add_suffix

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

Suffix labels with string suffix.

See more: bigframes.series.Series.add_suffix

bigframes.series.Series.agg

agg(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.series.Series.agg

bigframes.series.Series.aggregate

aggregate(
    func: typing.Union[str, typing.Sequence[str]],
) -> typing.Union[typing.Any, bigframes.series.Series]

Aggregate using one or more operations over the specified axis.

See more: bigframes.series.Series.aggregate

bigframes.series.Series.all

all() -> bool

Return whether all elements are True, potentially over an axis.

See more: bigframes.series.Series.all

bigframes.series.Series.any

any() -> bool

Return whether any element is True, potentially over an axis.

See more: bigframes.series.Series.any

bigframes.series.Series.apply

apply(
    func,
    by_row: typing.Union[typing.Literal["compat"], bool] = "compat",
    *,
    args: typing.Tuple = ()
) -> bigframes.series.Series

Invoke function on values of a Series.

See more: bigframes.series.Series.apply

bigframes.series.Series.area

area(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    stacked: bool = True,
    **kwargs
)

Draw a stacked area plot.

See more: bigframes.series.Series.area

bigframes.series.Series.argmax

argmax() -> int

Return int position of the largest value in the series.

See more: bigframes.series.Series.argmax

bigframes.series.Series.argmin

argmin() -> int

Return int position of the smallest value in the Series.

See more: bigframes.series.Series.argmin

bigframes.series.Series.astype

astype(
    dtype: typing.Union[
        typing.Literal[
            "boolean",
            "Float64",
            "Int64",
            "int64[pyarrow]",
            "string",
            "string[pyarrow]",
            "timestamp[us, tz=UTC][pyarrow]",
            "timestamp[us][pyarrow]",
            "date32[day][pyarrow]",
            "time64[us][pyarrow]",
            "decimal128(38, 9)[pyarrow]",
            "decimal256(76, 38)[pyarrow]",
            "binary[pyarrow]",
            "duration[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,
        geopandas.array.GeometryDtype,
    ],
    *,
    errors: typing.Literal["raise", "null"] = "raise"
) -> bigframes.series.Series

Cast a pandas object to a specified dtype dtype.

See more: bigframes.series.Series.astype

bigframes.series.Series.autocorr

autocorr(lag: int = 1) -> float

Compute the lag-N autocorrelation.

See more: bigframes.series.Series.autocorr

bigframes.series.Series.bar

bar(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Draw a vertical bar plot.

See more: bigframes.series.Series.bar

bigframes.series.Series.between

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

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

See more: bigframes.series.Series.between

bigframes.series.Series.bfill

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

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

See more: bigframes.series.Series.bfill

bigframes.series.Series.cache

cache()

Materializes the Series to a temporary table.

See more: bigframes.series.Series.cache

bigframes.series.Series.case_when

case_when(caselist) -> bigframes.series.Series

Replace values where the conditions are True.

See more: bigframes.series.Series.case_when

bigframes.series.Series.clip

clip(lower=None, upper=None)

Trim values at input threshold(s).

See more: bigframes.series.Series.clip

bigframes.series.Series.combine

combine(other, func) -> bigframes.series.Series

Combine the Series with a Series or scalar according to func.

See more: bigframes.series.Series.combine

bigframes.series.Series.combine_first

combine_first(other: bigframes.series.Series) -> bigframes.series.Series

Update null elements with value in the same location in 'other'.

See more: bigframes.series.Series.combine_first

bigframes.series.Series.copy

copy() -> bigframes.series.Series

Make a copy of this object's indices and data.

See more: bigframes.series.Series.copy

bigframes.series.Series.corr

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

Compute the correlation with the other Series.

See more: bigframes.series.Series.corr

bigframes.series.Series.count

count() -> int

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

See more: bigframes.series.Series.count

bigframes.series.Series.cov

cov(other: bigframes.series.Series) -> float

Compute covariance with Series, excluding missing values.

See more: bigframes.series.Series.cov

bigframes.series.Series.cummax

cummax() -> bigframes.series.Series

Return cumulative maximum over a DataFrame or Series axis.

See more: bigframes.series.Series.cummax

bigframes.series.Series.cummin

cummin() -> bigframes.series.Series

Return cumulative minimum over a DataFrame or Series axis.

See more: bigframes.series.Series.cummin

bigframes.series.Series.cumprod

cumprod() -> bigframes.series.Series

Return cumulative product over a DataFrame or Series axis.

See more: bigframes.series.Series.cumprod

bigframes.series.Series.cumsum

cumsum() -> bigframes.series.Series

Return cumulative sum over a DataFrame or Series axis.

See more: bigframes.series.Series.cumsum

bigframes.series.Series.describe

describe() -> bigframes.series.Series

Generate descriptive statistics.

See more: bigframes.series.Series.describe

bigframes.series.Series.diff

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

First discrete difference of element.

See more: bigframes.series.Series.diff

bigframes.series.Series.div

div(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.div

bigframes.series.Series.divide

divide(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.divide

bigframes.series.Series.divmod

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

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

See more: bigframes.series.Series.divmod

bigframes.series.Series.dot

dot(other)

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

See more: bigframes.series.Series.dot

bigframes.series.Series.drop

drop(
    labels: typing.Any = None,
    *,
    axis: typing.Union[int, str] = 0,
    index: typing.Any = None,
    columns: 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.

See more: bigframes.series.Series.drop

bigframes.series.Series.drop_duplicates

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

Return Series with duplicate values removed.

See more: bigframes.series.Series.drop_duplicates

bigframes.series.Series.droplevel

droplevel(
    level: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

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

See more: bigframes.series.Series.droplevel

bigframes.series.Series.dropna

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.

See more: bigframes.series.Series.dropna

bigframes.series.Series.duplicated

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

Indicate duplicate Series values.

See more: bigframes.series.Series.duplicated

bigframes.series.Series.eq

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

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

See more: bigframes.series.Series.eq

bigframes.series.Series.equals

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

Test whether two objects contain the same elements.

See more: bigframes.series.Series.equals

bigframes.series.Series.expanding

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

Provide expanding window calculations.

See more: bigframes.series.Series.expanding

bigframes.series.Series.explode

explode(*, ignore_index: typing.Optional[bool] = False) -> bigframes.series.Series

Transform each element of a list-like to a row.

See more: bigframes.series.Series.explode

bigframes.series.Series.ffill

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

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

See more: bigframes.series.Series.ffill

bigframes.series.Series.fillna

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

Fill NA (NULL in BigQuery) values using the specified method.

See more: bigframes.series.Series.fillna

bigframes.series.Series.filter

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.

See more: bigframes.series.Series.filter

bigframes.series.Series.floordiv

floordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.floordiv

bigframes.series.Series.ge

ge(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.ge

bigframes.series.Series.get

get(key, default=None)

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

See more: bigframes.series.Series.get

bigframes.series.Series.groupby

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

Group Series using a mapper or by a Series of columns.

See more: bigframes.series.Series.groupby

bigframes.series.Series.gt

gt(other) -> bigframes.series.Series

Return Greater than of series and other, element-wise (binary operator gt).

See more: bigframes.series.Series.gt

bigframes.series.Series.head

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

Return the first n rows.

See more: bigframes.series.Series.head

bigframes.series.Series.hist

hist(by: typing.Optional[typing.Sequence[str]] = None, bins: int = 10, **kwargs)

Draw one histogram of the DataFrame’s columns.

See more: bigframes.series.Series.hist

bigframes.series.Series.idxmax

idxmax() -> typing.Hashable

Return the row label of the maximum value.

See more: bigframes.series.Series.idxmax

bigframes.series.Series.idxmin

idxmin() -> typing.Hashable

Return the row label of the minimum value.

See more: bigframes.series.Series.idxmin

bigframes.series.Series.interpolate

interpolate(method: str = "linear") -> bigframes.series.Series

Fill NaN values using an interpolation method.

See more: bigframes.series.Series.interpolate

bigframes.series.Series.isin

isin(values) -> bigframes.series.Series

Whether elements in Series are contained in values.

See more: bigframes.series.Series.isin

bigframes.series.Series.isna

isna() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.series.Series.isna

bigframes.series.Series.isnull

isnull() -> bigframes.series.Series

Detect missing (NULL) values.

See more: bigframes.series.Series.isnull

bigframes.series.Series.item

item()

Return the first element of the underlying data as a Python scalar.

See more: bigframes.series.Series.item

bigframes.series.Series.items

items()

Lazily iterate over (index, value) tuples.

See more: bigframes.series.Series.items

bigframes.series.Series.keys

keys() -> bigframes.core.indexes.base.Index

Return alias for index.

See more: bigframes.series.Series.keys

bigframes.series.Series.kurt

kurt()

Return unbiased kurtosis over requested axis.

See more: bigframes.series.Series.kurt

bigframes.series.Series.kurtosis

kurtosis()

Return unbiased kurtosis over requested axis.

See more: bigframes.series.Series.kurtosis

bigframes.series.Series.le

le(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.le

bigframes.series.Series.line

line(
    x: typing.Optional[typing.Hashable] = None,
    y: typing.Optional[typing.Hashable] = None,
    **kwargs
)

Plot Series or DataFrame as lines.

See more: bigframes.series.Series.line

bigframes.series.Series.lt

lt(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.lt

bigframes.series.Series.map

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

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

See more: bigframes.series.Series.map

bigframes.series.Series.mask

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

Replace values where the condition is True.

See more: bigframes.series.Series.mask

bigframes.series.Series.max

max() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.series.Series.max

bigframes.series.Series.mean

mean() -> float

Return the mean of the values over the requested axis.

See more: bigframes.series.Series.mean

bigframes.series.Series.median

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

Return the median of the values over the requested axis.

See more: bigframes.series.Series.median

bigframes.series.Series.min

min() -> typing.Any

Return the maximum of the values over the requested axis.

See more: bigframes.series.Series.min

bigframes.series.Series.mod

mod(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.mod

bigframes.series.Series.mode

mode() -> bigframes.series.Series

Return the mode(s) of the Series.

See more: bigframes.series.Series.mode

bigframes.series.Series.mul

mul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.series.Series.mul

bigframes.series.Series.multiply

multiply(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.series.Series.multiply

bigframes.series.Series.ne

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

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

See more: bigframes.series.Series.ne

bigframes.series.Series.nlargest

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

Return the largest n elements.

See more: bigframes.series.Series.nlargest

bigframes.series.Series.notna

notna() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.series.Series.notna

bigframes.series.Series.notnull

notnull() -> bigframes.series.Series

Detect existing (non-missing) values.

See more: bigframes.series.Series.notnull

bigframes.series.Series.nsmallest

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

Return the smallest n elements.

See more: bigframes.series.Series.nsmallest

bigframes.series.Series.nunique

nunique() -> int

Return number of unique elements in the object.

See more: bigframes.series.Series.nunique

bigframes.series.Series.pad

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

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

See more: bigframes.series.Series.pad

bigframes.series.Series.pct_change

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

Fractional change between the current and a prior element.

See more: bigframes.series.Series.pct_change

bigframes.series.Series.peek

peek(
    n: int = 5, *, force: bool = True, allow_large_results=None
) -> pandas.core.series.Series

Preview n arbitrary elements from the series without guarantees about row selection or ordering.

See more: bigframes.series.Series.peek

bigframes.series.Series.pipe

pipe(func: Callable[..., T] | tuple[Callable[..., T], str], *args, **kwargs) -> T

Apply chainable functions that expect Series or DataFrames.

See more: bigframes.series.Series.pipe

bigframes.series.Series.pow

pow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.series.Series.pow

bigframes.series.Series.prod

prod() -> float

Return the product of the values over the requested axis.

See more: bigframes.series.Series.prod

bigframes.series.Series.product

product() -> float

Return the product of the values over the requested axis.

See more: bigframes.series.Series.product

bigframes.series.Series.quantile

quantile(
    q: typing.Union[float, typing.Sequence[float]] = 0.5,
) -> typing.Union[bigframes.series.Series, float]

Return value at the given quantile.

See more: bigframes.series.Series.quantile

bigframes.series.Series.radd

radd(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.radd

bigframes.series.Series.rank

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

Compute numerical data ranks (1 through n) along axis.

See more: bigframes.series.Series.rank

bigframes.series.Series.rdiv

rdiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.rdiv

bigframes.series.Series.rdivmod

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

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

See more: bigframes.series.Series.rdivmod

bigframes.series.Series.reindex

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

Conform Series to new index with optional filling logic.

See more: bigframes.series.Series.reindex

bigframes.series.Series.reindex_like

reindex_like(
    other: bigframes.series.Series, *, validate: typing.Optional[bool] = None
)

Return an object with matching indices as other object.

See more: bigframes.series.Series.reindex_like

bigframes.series.Series.rename

Alter Series index labels or name.

See more: bigframes.series.Series.rename

bigframes.series.Series.rename_axis

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

See more: bigframes.series.Series.rename_axis

bigframes.series.Series.reorder_levels

reorder_levels(
    order: typing.Union[str, int, typing.Sequence[typing.Union[str, int]]],
    axis: int | str = 0,
)

Rearrange index levels using input order.

See more: bigframes.series.Series.reorder_levels

bigframes.series.Series.replace

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

Replace values given in to_replace with value.

See more: bigframes.series.Series.replace

bigframes.series.Series.resample

resample(
    rule: str,
    *,
    closed: typing.Optional[typing.Literal["right", "left"]] = None,
    label: typing.Optional[typing.Literal["right", "left"]] = None,
    level: typing.Optional[
        typing.Union[str, int, typing.Sequence[typing.Union[str, int]]]
    ] = None,
    origin: typing.Union[
        pandas._libs.tslibs.timestamps.Timestamp,
        datetime.datetime,
        numpy.datetime64,
        int,
        float,
        str,
        typing.Literal["epoch", "start", "start_day", "end", "end_day"],
    ] = "start_day"
) -> bigframes.core.groupby.series_group_by.SeriesGroupBy

Resample time-series data.

See more: bigframes.series.Series.resample

bigframes.series.Series.reset_index

Generate a new DataFrame or Series with the index reset.

See more: bigframes.series.Series.reset_index

bigframes.series.Series.rfloordiv

rfloordiv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.rfloordiv

bigframes.series.Series.rmod

rmod(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.rmod

bigframes.series.Series.rmul

rmul(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.series.Series.rmul

bigframes.series.Series.rolling

rolling(
    window: (
        int
        | pandas._libs.tslibs.timedeltas.Timedelta
        | numpy.timedelta64
        | datetime.timedelta
        | str
    ),
    min_periods: int | None = None,
    closed: typing.Literal["right", "left", "both", "neither"] = "right",
) -> bigframes.core.window.rolling.Window

Provide rolling window calculations.

See more: bigframes.series.Series.rolling

bigframes.series.Series.round

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

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

See more: bigframes.series.Series.round

bigframes.series.Series.rpow

rpow(other: float | int | bigframes.series.Series) -> bigframes.series.Series

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

See more: bigframes.series.Series.rpow

bigframes.series.Series.rsub

rsub(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.rsub

bigframes.series.Series.rtruediv

rtruediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.rtruediv

bigframes.series.Series.sample

sample(
    n: typing.Optional[int] = None,
    frac: typing.Optional[float] = None,
    *,
    random_state: typing.Optional[int] = None,
    sort: typing.Optional[typing.Union[bool, typing.Literal["random"]]] = "random"
) -> bigframes.series.Series

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

See more: bigframes.series.Series.sample

bigframes.series.Series.shift

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

Shift index by desired number of periods.

See more: bigframes.series.Series.shift

bigframes.series.Series.skew

skew()

Return unbiased skew over requested axis.

See more: bigframes.series.Series.skew

bigframes.series.Series.sort_index

Sort Series by index labels.

See more: bigframes.series.Series.sort_index

bigframes.series.Series.sort_values

Sort by the values.

See more: bigframes.series.Series.sort_values

bigframes.series.Series.std

std() -> float

Return sample standard deviation over requested axis.

See more: bigframes.series.Series.std

bigframes.series.Series.sub

sub(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.sub

bigframes.series.Series.subtract

subtract(other) -> bigframes.series.Series

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

See more: bigframes.series.Series.subtract

bigframes.series.Series.sum

sum() -> float

Return the sum of the values over the requested axis.

See more: bigframes.series.Series.sum

bigframes.series.Series.swaplevel

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

Swap levels i and j in a MultiIndex.

See more: bigframes.series.Series.swaplevel

bigframes.series.Series.tail

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

Return the last n rows.

See more: bigframes.series.Series.tail

bigframes.series.Series.take

take(
    indices: typing.Sequence[int], axis: int | str | None = 0, **kwargs
) -> bigframes.series.Series

Return the elements in the given positional indices along an axis.

See more: bigframes.series.Series.take

bigframes.series.Series.to_csv

to_csv(
    path_or_buf=None,
    sep=",",
    *,
    header: bool = True,
    index: bool = True,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Optional[str]

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

See more: bigframes.series.Series.to_csv

bigframes.series.Series.to_dict

to_dict(
    into: type[dict] = dict, *, allow_large_results: typing.Optional[bool] = None
) -> typing.Mapping

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

See more: bigframes.series.Series.to_dict

bigframes.series.Series.to_excel

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

Write Series to an Excel sheet.

See more: bigframes.series.Series.to_excel

bigframes.series.Series.to_frame

to_frame(name: typing.Hashable = None) -> bigframes.dataframe.DataFrame

Convert Series to DataFrame.

See more: bigframes.series.Series.to_frame

bigframes.series.Series.to_json

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

Convert the object to a JSON string, written to Cloud Storage.

See more: bigframes.series.Series.to_json

bigframes.series.Series.to_latex

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

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

See more: bigframes.series.Series.to_latex

bigframes.series.Series.to_list

to_list(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.series.Series.to_list

bigframes.series.Series.to_markdown

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

Print Series in Markdown-friendly format.

See more: bigframes.series.Series.to_markdown

bigframes.series.Series.to_numpy

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

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

See more: bigframes.series.Series.to_numpy

bigframes.series.Series.to_pandas

to_pandas(
    max_download_size: typing.Optional[int] = None,
    sampling_method: typing.Optional[str] = None,
    random_state: typing.Optional[int] = None,
    *,
    ordered: bool = True,
    dry_run: bool = False,
    allow_large_results: typing.Optional[bool] = None
) -> pandas.core.series.Series

Writes Series to pandas Series.

See more: bigframes.series.Series.to_pandas

bigframes.series.Series.to_pandas_batches

to_pandas_batches(
    page_size: typing.Optional[int] = None,
    max_results: typing.Optional[int] = None,
    *,
    allow_large_results: typing.Optional[bool] = None
) -> typing.Iterable[pandas.core.series.Series]

Stream Series results to an iterable of pandas Series.

See more: bigframes.series.Series.to_pandas_batches

bigframes.series.Series.to_pickle

to_pickle(path, *, allow_large_results=None, **kwargs) -> None

Pickle (serialize) object to file.

See more: bigframes.series.Series.to_pickle

bigframes.series.Series.to_string

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,
    *,
    allow_large_results=None
) -> typing.Optional[str]

Render a string representation of the Series.

See more: bigframes.series.Series.to_string

bigframes.series.Series.to_xarray

to_xarray(*, allow_large_results: typing.Optional[bool] = None)

Return an xarray object from the pandas object.

See more: bigframes.series.Series.to_xarray

bigframes.series.Series.tolist

tolist(*, allow_large_results: typing.Optional[bool] = None) -> list

Return a list of the values.

See more: bigframes.series.Series.tolist

bigframes.series.Series.transpose

transpose() -> bigframes.series.Series

Return the transpose, which is by definition self.

See more: bigframes.series.Series.transpose

bigframes.series.Series.truediv

truediv(
    other: (
        float | int | pandas._libs.tslibs.timedeltas.Timedelta | bigframes.series.Series
    ),
) -> bigframes.series.Series

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

See more: bigframes.series.Series.truediv

bigframes.series.Series.unique

unique(keep_order=True) -> bigframes.series.Series

Return unique values of Series object.

See more: bigframes.series.Series.unique

bigframes.series.Series.unstack

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

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

See more: bigframes.series.Series.unstack

bigframes.series.Series.update

update(
    other: typing.Union[bigframes.series.Series, typing.Sequence, typing.Mapping],
) -> None

Modify Series in place using values from passed Series.

See more: bigframes.series.Series.update

bigframes.series.Series.value_counts

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

Return a Series containing counts of unique values.

See more: bigframes.series.Series.value_counts

bigframes.series.Series.var

var() -> float

Return unbiased variance over requested axis.

See more: bigframes.series.Series.var

bigframes.series.Series.where

where(cond, other=None)

Replace values where the condition is False.

See more: bigframes.series.Series.where

bigframes.session.Session.DataFrame

DataFrame(*args, **kwargs)

Constructs a DataFrame.

See more: bigframes.session.Session.DataFrame

bigframes.session.Session.Index

Index(*args, **kwargs)

Constructs a Index.

See more: bigframes.session.Session.Index

bigframes.session.Session.Series

Series(*args, **kwargs)

Constructs a Series.

See more: bigframes.session.Session.Series

bigframes.session.Session.del

__del__()

Automatic cleanup of internal resources.

See more: bigframes.session.Session.del

bigframes.session.Session.enter

__enter__()

Enter the runtime context of the Session object.

See more: bigframes.session.Session.enter

bigframes.session.Session.exit

__exit__(*_)

Exit the runtime context of the Session object.

See more: bigframes.session.Session.exit

bigframes.session.Session.close

close()

Delete resources that were created with this session's session_id.

See more: bigframes.session.Session.close

bigframes.session.Session.cut

cut(*args, **kwargs) -> bigframes.series.Series

Cuts a BigQuery DataFrames object.

See more: bigframes.session.Session.cut

bigframes.session.Session.deploy_remote_function

deploy_remote_function(func, **kwargs)

Orchestrates the creation of a BigQuery remote function that deploys immediately.

See more: bigframes.session.Session.deploy_remote_function

bigframes.session.Session.deploy_udf

deploy_udf(func, **kwargs)

Orchestrates the creation of a BigQuery UDF that deploys immediately.

See more: bigframes.session.Session.deploy_udf

bigframes.session.Session.from_glob_path

from_glob_path(
    path: str, *, connection: Optional[str] = None, name: Optional[str] = None
) -> dataframe.DataFrame

Create a BigFrames DataFrame that contains a BigFrames Blob column from a global wildcard path.

See more: bigframes.session.Session.from_glob_path

bigframes.session.Session.read_arrow

read_arrow(pa_table: pyarrow.lib.Table) -> bigframes.dataframe.DataFrame

Load a PyArrow Table to a BigQuery DataFrames DataFrame.

See more: bigframes.session.Session.read_arrow

bigframes.session.Session.read_csv

read_csv(
    filepath_or_buffer: str | IO["bytes"],
    *,
    sep: Optional[str] = ",",
    header: Optional[int] = 0,
    names: Optional[
        Union[MutableSequence[Any], np.ndarray[Any, Any], Tuple[Any, ...], range]
    ] = None,
    index_col: Optional[
        Union[
            int,
            str,
            Sequence[Union[str, int]],
            bigframes.enums.DefaultIndexKind,
            Literal[False],
        ]
    ] = None,
    usecols: Optional[
        Union[
            MutableSequence[str],
            Tuple[str, ...],
            Sequence[int],
            pandas.Series,
            pandas.Index,
            np.ndarray[Any, Any],
            Callable[[Any], bool],
        ]
    ] = None,
    dtype: Optional[Dict] = None,
    engine: Optional[
        Literal["c", "python", "pyarrow", "python-fwf", "bigquery"]
    ] = None,
    encoding: Optional[str] = None,
    write_engine: constants.WriteEngineType = "default",
    **kwargs
) -> dataframe.DataFrame

Loads data from a comma-separated values (csv) file into a DataFrame.

See more: bigframes.session.Session.read_csv

bigframes.session.Session.read_gbq

Loads a DataFrame from BigQuery.

See more: bigframes.session.Session.read_gbq

bigframes.session.Session.read_gbq_function

read_gbq_function(function_name: str, is_row_processor: bool = False)

Loads a BigQuery function from BigQuery.

See more: bigframes.session.Session.read_gbq_function

bigframes.session.Session.read_gbq_model

read_gbq_model(model_name: str)

Loads a BigQuery ML model from BigQuery.

See more: bigframes.session.Session.read_gbq_model

bigframes.session.Session.read_gbq_object_table

read_gbq_object_table(
    object_table: str, *, name: Optional[str] = None
) -> dataframe.DataFrame

Read an existing object table to create a BigFrames Blob DataFrame.

See more: bigframes.session.Session.read_gbq_object_table

bigframes.session.Session.read_gbq_query

Turn a SQL query into a DataFrame.

See more: bigframes.session.Session.read_gbq_query

bigframes.session.Session.read_gbq_table

Turn a BigQuery table into a DataFrame.

See more: bigframes.session.Session.read_gbq_table

bigframes.session.Session.read_gbq_table_streaming

read_gbq_table_streaming(table: str) -> streaming_dataframe.StreamingDataFrame

Turn a BigQuery table into a StreamingDataFrame.

See more: bigframes.session.Session.read_gbq_table_streaming

bigframes.session.Session.read_json

read_json(
    path_or_buf: str | IO["bytes"],
    *,
    orient: Literal[
        "split", "records", "index", "columns", "values", "table"
    ] = "columns",
    dtype: Optional[Dict] = None,
    encoding: Optional[str] = None,
    lines: bool = False,
    engine: Literal["ujson", "pyarrow", "bigquery"] = "ujson",
    write_engine: constants.WriteEngineType = "default",
    **kwargs
) -> dataframe.DataFrame

Convert a JSON string to DataFrame object.

See more: bigframes.session.Session.read_json

bigframes.session.Session.read_pandas

Loads DataFrame from a pandas DataFrame.

See more: bigframes.session.Session.read_pandas

bigframes.session.Session.read_parquet

read_parquet(
    path: str | IO["bytes"],
    *,
    engine: str = "auto",
    write_engine: constants.WriteEngineType = "default"
) -> dataframe.DataFrame

Load a Parquet object from the file path (local or Cloud Storage), returning a DataFrame.

See more: bigframes.session.Session.read_parquet

bigframes.session.Session.read_pickle

read_pickle(
    filepath_or_buffer: FilePath | ReadPickleBuffer,
    compression: CompressionOptions = "infer",
    storage_options: StorageOptions = None,
    *,
    write_engine: constants.WriteEngineType = "default"
)

Load pickled BigFrames object (or any object) from file.

See more: bigframes.session.Session.read_pickle

bigframes.session.Session.remote_function

remote_function(
    input_types: typing.Union[None, type, typing.Sequence[type]] = None,
    output_type: typing.Optional[type] = None,
    dataset: typing.Optional[str] = None,
    *,
    bigquery_connection: typing.Optional[str] = None,
    reuse: bool = True,
    name: typing.Optional[str] = None,
    packages: typing.Optional[typing.Sequence[str]] = None,
    cloud_function_service_account: str,
    cloud_function_kms_key_name: typing.Optional[str] = None,
    cloud_function_docker_repository: typing.Optional[str] = None,
    max_batching_rows: typing.Optional[int] = 1000,
    cloud_function_timeout: typing.Optional[int] = 600,
    cloud_function_max_instances: typing.Optional[int] = None,
    cloud_function_vpc_connector: typing.Optional[str] = None,
    cloud_function_vpc_connector_egress_settings: typing.Optional[
        typing.Literal["all", "private-ranges-only", "unspecified"]
    ] = None,
    cloud_function_memory_mib: typing.Optional[int] = 1024,
    cloud_function_ingress_settings: typing.Literal[
        "all", "internal-only", "internal-and-gclb"
    ] = "internal-only",
    cloud_build_service_account: typing.Optional[str] = None
)

Decorator to turn a user defined function into a BigQuery remote function.

See more: bigframes.session.Session.remote_function

bigframes.session.Session.to_datetime

to_datetime(
    *args, **kwargs
) -> typing.Union[
    pandas._libs.tslibs.timestamps.Timestamp, datetime.datetime, bigframes.series.Series
]

Converts a BigQuery DataFrames object to datetime dtype.

See more: bigframes.session.Session.to_datetime

bigframes.session.Session.to_timedelta

to_timedelta(*args, **kwargs)

Converts a BigQuery DataFrames object to timedelta/duration dtype.

See more: bigframes.session.Session.to_timedelta

bigframes.session.Session.udf

udf(
    *,
    input_types: typing.Union[None, type, typing.Sequence[type]] = None,
    output_type: typing.Optional[type] = None,
    dataset: str,
    bigquery_connection: typing.Optional[str] = None,
    name: str,
    packages: typing.Optional[typing.Sequence[str]] = None,
    max_batching_rows: typing.Optional[int] = None,
    container_cpu: typing.Optional[float] = None,
    container_memory: typing.Optional[str] = None
)

Decorator to turn a Python user defined function (udf) into a BigQuery managed user-defined function.

See more: bigframes.session.Session.udf

bigframes.streaming.dataframe.StreamingDataFrame.getitem

__getitem__(*args, **kwargs)

Gets the specified column(s) from the StreamingDataFrame.

See more: bigframes.streaming.dataframe.StreamingDataFrame.getitem

bigframes.streaming.dataframe.StreamingDataFrame.repr

__repr__(*args, **kwargs)

Converts a StreamingDataFrame to a string.

See more: bigframes.streaming.dataframe.StreamingDataFrame.repr

bigframes.streaming.dataframe.StreamingDataFrame.setitem

__setitem__(*args, **kwargs)

Modify or insert a column into the StreamingDataFrame.

See more: bigframes.streaming.dataframe.StreamingDataFrame.setitem

bigframes.streaming.dataframe.StreamingDataFrame.rename

rename(*args, **kwargs)

Rename columns.

See more: bigframes.streaming.dataframe.StreamingDataFrame.rename

bigframes.streaming.dataframe.StreamingDataFrame.to_bigtable

to_bigtable(
    *,
    instance: str,
    table: str,
    service_account_email: typing.Optional[str] = None,
    app_profile: typing.Optional[str] = None,
    truncate: bool = False,
    overwrite: bool = False,
    auto_create_column_families: bool = False,
    bigtable_options: typing.Optional[dict] = None,
    job_id: typing.Optional[str] = None,
    job_id_prefix: typing.Optional[str] = None,
    start_timestamp: typing.Optional[
        typing.Union[int, float, str, datetime.datetime, datetime.date]
    ] = None,
    end_timestamp: typing.Optional[
        typing.Union[int, float, str, datetime.datetime, datetime.date]
    ] = None
) -> google.cloud.bigquery.job.query.QueryJob

Export the StreamingDataFrame as a continue job and returns a QueryJob object for some management functionality.

See more: bigframes.streaming.dataframe.StreamingDataFrame.to_bigtable

bigframes.streaming.dataframe.StreamingDataFrame.to_pubsub

to_pubsub(
    *,
    topic: str,
    service_account_email: str,
    job_id: typing.Optional[str] = None,
    job_id_prefix: typing.Optional[str] = None,
    start_timestamp: typing.Optional[
        typing.Union[int, float, str, datetime.datetime, datetime.date]
    ] = None
) -> google.cloud.bigquery.job.query.QueryJob

Export the StreamingDataFrame as a continue job and returns a QueryJob object for some management functionality.

See more: bigframes.streaming.dataframe.StreamingDataFrame.to_pubsub

Package Methods (2.29.0) Stay organized with collections Save and categorize content based on your preferences.

bigframes.bigquery.approx_top_count

bigframes.bigquery.array_agg

bigframes.bigquery.array_length

bigframes.bigquery.array_to_string

bigframes.bigquery.create_vector_index

bigframes.bigquery.json_extract

bigframes.bigquery.json_extract_array

bigframes.bigquery.json_extract_string_array

bigframes.bigquery.json_query

bigframes.bigquery.json_query_array

bigframes.bigquery.json_set

bigframes.bigquery.json_value

bigframes.bigquery.json_value_array

bigframes.bigquery.parse_json

bigframes.bigquery.sql_scalar

bigframes.bigquery.st_area

bigframes.bigquery.st_buffer

bigframes.bigquery.st_centroid

bigframes.bigquery.st_convexhull

bigframes.bigquery.st_difference

bigframes.bigquery.st_distance

bigframes.bigquery.st_intersection

bigframes.bigquery.st_isclosed

bigframes.bigquery.st_length

bigframes.bigquery.st_regionstats

bigframes.bigquery.st_simplify

bigframes.bigquery.struct

bigframes.bigquery.to_json

bigframes.bigquery.to_json_string

bigframes.bigquery.unix_micros

bigframes.bigquery.unix_millis

bigframes.bigquery.unix_seconds

bigframes.bigquery.vector_search

bigframes.bigquery._operations.ai.classify

bigframes.bigquery._operations.ai.forecast

bigframes.bigquery._operations.ai.generate

bigframes.bigquery._operations.ai.generate_bool

bigframes.bigquery._operations.ai.generate_double

bigframes.bigquery._operations.ai.generate_int

bigframes.bigquery._operations.ai.if_

bigframes.bigquery._operations.ai.score

bigframes.exceptions.format_message

bigframes.ml.metrics.accuracy_score

bigframes.ml.metrics.auc

bigframes.ml.metrics.confusion_matrix

bigframes.ml.metrics.f1_score

bigframes.ml.metrics.mean_absolute_error

bigframes.ml.metrics.mean_squared_error

bigframes.ml.metrics.precision_score

bigframes.ml.metrics.r2_score

bigframes.ml.metrics.recall_score

bigframes.ml.metrics.roc_auc_score

bigframes.ml.metrics.roc_curve

bigframes.ml.metrics.pairwise.paired_cosine_distances

bigframes.ml.metrics.pairwise.paired_euclidean_distances

bigframes.ml.metrics.pairwise.paired_manhattan_distance

bigframes.ml.model_selection.cross_validate

bigframes.ml.model_selection.train_test_split

bigframes.pandas.clean_up_by_session_id

bigframes.pandas.close_session

bigframes.pandas.concat

bigframes.pandas.cut

bigframes.pandas.deploy_remote_function

bigframes.pandas.deploy_udf

bigframes.pandas.from_glob_path

bigframes.pandas.get_default_session_id

bigframes.pandas.get_dummies

bigframes.pandas.get_global_session

bigframes.pandas.merge

bigframes.pandas.qcut

bigframes.pandas.read_arrow

bigframes.pandas.read_csv

bigframes.pandas.read_gbq

bigframes.pandas.read_gbq_function

bigframes.pandas.read_gbq_model

bigframes.pandas.read_gbq_object_table

bigframes.pandas.read_gbq_query

bigframes.pandas.read_gbq_table

bigframes.pandas.read_json

Package Methods (2.29.0)