Python dask.dataframe.Series.reduction用法及代码示例

用法:
Series.reduction(chunk, aggregate=None, combine=None, meta='__no_default__', token=None, split_every=None, chunk_kwargs=None, aggregate_kwargs=None, combine_kwargs=None, **kwargs)

通用的逐行缩减。

参数：

chunk：可调用的

对每个分区进行操作的函数。应该返回 pandas.DataFrame , pandas.Series 或标量。

aggregate：可调用的，可选的

对 chunk 的连接结果进行操作的函数。如果未指定，则默认为 chunk 。用于在树归约中进行最终聚合。

aggregate 的输入取决于 chunk 的输出。如果chunk 的输出是：

标量：输入是一个系列，每个分区有一行。
系列：输入是一个 DataFrame，每个分区有一行。列是输出系列中的行。
DataFrame：输入是一个DataFrame，每个分区一行。列是输出 DataFrame 中的列。

应该返回 pandas.DataFrame , pandas.Series 或标量。

combine：可调用的，可选的

对tree-reduction 中chunk 的中间级联结果进行操作的函数。如果未提供，则默认为 aggregate 。输入/输出要求应与上述aggregate 相匹配。

meta：pd.DataFrame、pd.Series、dict、可迭代、元组、可选

与输出的 dtypes 和列名匹配的空 pd.DataFrame 或 pd.Series。此元数据对于 dask 数据帧中的许多算法起作用是必需的。为了便于使用，还提供了一些替代输入。可以提供 {name: dtype} 的 dict 或 (name, dtype) 的可迭代对象，而不是 DataFrame (请注意，名称的顺序应与列的顺序匹配)。可以使用(name, dtype) 的元组代替系列。如果未提供，dask 将尝试推断元数据。这可能会导致意外结果，因此建议提供meta。有关详细信息，请参阅 dask.dataframe.utils.make_meta 。

token：str，可选

用于输出键的名称。

split_every：整数，可选

在执行tree-reduction 时将分区分组为该大小的组。如果设置为 False，则不会使用 tree-reduction，所有中间体将被连接并传递给 aggregate 。默认值为 8。

chunk_kwargs：字典，可选

仅传递给chunk 的关键字参数。

aggregate_kwargs：字典，可选

仅传递给aggregate 的关键字参数。

combine_kwargs：字典，可选

仅传递给combine 的关键字参数。

kwargs：

所有剩余的关键字都将传递给 chunk , combine 和 aggregate 。

例子：

>>> import pandas as pd
>>> import dask.dataframe as dd
>>> df = pd.DataFrame({'x': range(50), 'y': range(50, 100)})
>>> ddf = dd.from_pandas(df, npartitions=4)

计算 DataFrame 中的行数。为此，请计算每个分区中的行数，然后对结果求和：

>>> res = ddf.reduction(lambda x: x.count(),
...                     aggregate=lambda x: x.sum())
>>> res.compute()
x    50
y    50
dtype: int64

计算 Series 中元素大于或等于某个值(通过关键字提供)的行数。

>>> def count_greater(x, value=0):
...     return (x >= value).sum()
>>> res = ddf.x.reduction(count_greater, aggregate=lambda x: x.sum(),
...                       chunk_kwargs={'value': 25})
>>> res.compute()
25

同时聚合一个系列的总和和计数：

>>> def sum_and_count(x):
...     return pd.Series({'count': x.count(), 'sum': x.sum()},
...                      index=['count', 'sum'])
>>> res = ddf.x.reduction(sum_and_count, aggregate=lambda x: x.sum())
>>> res.compute()
count      50
sum      1225
dtype: int64

做同样的事情，但对于 DataFrame。这里chunk 返回一个DataFrame，这意味着aggregate 的输入是一个DataFrame，其索引包含两个‘x’ and ‘y’ 的非唯一条目。我们按索引分组，并对每个组求和以获得最终结果。

>>> def sum_and_count(x):
...     return pd.DataFrame({'count': x.count(), 'sum': x.sum()},
...                         columns=['count', 'sum'])
>>> res = ddf.reduction(sum_and_count,
...                     aggregate=lambda x: x.groupby(level=0).sum())
>>> res.compute()
   count   sum
x     50  1225
y     50  3725

相关用法

注：本文由纯净天空筛选整理自dask.org大神的英文原创作品 dask.dataframe.Series.reduction。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。