切换导航

.rst .pdf

内容

Dask DataFrame API（遗留版本）

数据框

DataFrame(dsk, name, meta, divisions)	并行 Pandas DataFrame
DataFrame.abs()	返回一个包含每个元素绝对数值的 Series/DataFrame。
DataFrame.add(other[, axis, level, fill_value])	获取数据框和其他对象的逐元素相加结果（二元运算符 add）。
DataFrame.align(other[, join, axis, fill_value])	使用指定的连接方法将两个对象沿其轴对齐。
DataFrame.all([axis, skipna, split_every, out])	返回是否所有元素都为 True，可能是在某个轴上。
DataFrame.any([axis, skipna, split_every, out])	返回是否任何元素为 True，可能在某个轴上。
DataFrame.apply(func[, axis, broadcast, ...])	pandas.DataFrame.apply 的并行版本
DataFrame.applymap(func[, meta])	对 Dataframe 的每个元素应用一个函数。
DataFrame.assign(**kwargs)	将新列分配给 DataFrame。
DataFrame.astype(dtype)	将 pandas 对象转换为指定的数据类型 dtype。
DataFrame.bfill([axis, limit])	使用下一个有效观测值来填充NA/NaN值。
DataFrame.categorize([columns, index, ...])	将 DataFrame 的列转换为类别数据类型。
DataFrame.columns
DataFrame.compute(**kwargs)	计算这个 dask 集合
DataFrame.copy([deep])	复制数据框
DataFrame.corr([method, min_periods, ...])	计算列之间的成对相关性，排除NA/null值。
DataFrame.count([axis, split_every, ...])	计算每列或每行的非NA单元格数量。
DataFrame.cov([min_periods, numeric_only, ...])	计算列之间的成对协方差，排除NA/空值。
DataFrame.cummax([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最大值。
DataFrame.cummin([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最小值。
DataFrame.cumprod([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积乘积。
DataFrame.cumsum([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积和。
DataFrame.describe([split_every, ...])	生成描述性统计数据。
DataFrame.diff([periods, axis])	元素的第一次离散差分。
DataFrame.div(other[, axis, level, fill_value])	获取数据框和其他对象的浮点数除法，逐元素进行（二元运算符 truediv）。
DataFrame.divide(other[, axis, level, ...])	获取数据框和其他对象的浮点数除法，逐元素进行（二元运算符 truediv）。
DataFrame.drop([labels, axis, columns, errors])	从行或列中删除指定的标签。
DataFrame.drop_duplicates([subset, ...])	返回删除了重复行的DataFrame。
DataFrame.dropna([how, subset, thresh])	移除缺失值。
DataFrame.dtypes	返回数据类型
DataFrame.eq(other[, axis, level])	获取数据框与其他的元素逐个相等的结果（二元运算符 eq）。
DataFrame.eval(expr[, inplace])	评估一个描述对DataFrame列进行操作的字符串。
DataFrame.explode(column)	将类似列表的每个元素转换为一行，复制索引值。
DataFrame.ffill([axis, limit])	通过将最后一个有效观测值传播到下一个有效值来填充 NA/NaN 值。
DataFrame.fillna([value, method, limit, axis])	使用指定方法填充 NA/NaN 值。
DataFrame.first(offset)	根据日期偏移选择时间序列数据的初始时间段。
DataFrame.floordiv(other[, axis, level, ...])	获取数据框和其他对象的整数除法，逐元素进行（二元运算符 floordiv）。
DataFrame.ge(other[, axis, level])	获取数据框和其他对象的元素级大于或等于结果（二进制运算符 ge）。
DataFrame.get_partition(n)	获取表示第 nth 分区的 dask DataFrame/Series。
DataFrame.groupby([by, group_keys, sort, ...])	使用映射器或按列的Series对DataFrame进行分组。
DataFrame.gt(other[, axis, level])	获取数据框和另一个数据框的元素级大于比较结果（二元运算符 gt）。
DataFrame.head([n, npartitions, compute])	数据集的前 n 行
DataFrame.idxmax([axis, skipna, ...])	返回请求轴上最大值的第一个出现的索引。
DataFrame.idxmin([axis, skipna, ...])	返回请求轴上最小值的首次出现的索引。
DataFrame.iloc	纯基于位置的整数索引，用于按位置选择。
DataFrame.index	返回 dask 索引实例
DataFrame.info([buf, verbose, memory_usage])	Dask DataFrame 的简要概述。
DataFrame.isin(values)	DataFrame 中的每个元素是否包含在值中。
DataFrame.isna()	检测缺失值。
DataFrame.isnull()	DataFrame.isnull 是 DataFrame.isna 的别名。
DataFrame.items()	遍历 (列名, 系列) 对。
DataFrame.iterrows()	遍历 DataFrame 行作为 (索引, 系列) 对。
DataFrame.itertuples([index, name])	将 DataFrame 行迭代为命名元组。
DataFrame.join(other[, on, how, lsuffix, ...])	连接另一个DataFrame的列。
DataFrame.known_divisions	分区是否已知
DataFrame.last(offset)	根据日期偏移选择时间序列数据的最后时间段。
DataFrame.le(other[, axis, level])	获取数据框和其他对象的元素级小于或等于（二进制运算符 le）。
DataFrame.loc	纯标签位置索引器，用于按标签选择。
DataFrame.lt(other[, axis, level])	获取数据框和其他对象的元素级小于比较（二元运算符 lt）。
DataFrame.map_partitions(func, *args, **kwargs)	在每个 DataFrame 分区上应用 Python 函数。
DataFrame.mask(cond[, other])	替换条件为 True 的值。
DataFrame.max([axis, skipna, split_every, ...])	返回请求轴上的值的最大值。
DataFrame.mean([axis, skipna, split_every, ...])	返回请求轴上值的平均值。
DataFrame.median([axis, method])	返回请求轴上值的中位数。
DataFrame.median_approximate([axis, method])	返回请求轴上值的近似中位数。
DataFrame.melt([id_vars, value_vars, ...])	将 DataFrame 从宽格式透视为长格式，可以选择保留标识变量集。
DataFrame.memory_usage([index, deep])	返回每个列的内存使用量，单位为字节。
DataFrame.memory_usage_per_partition([...])	返回每个分区的内存使用情况
DataFrame.merge(right[, how, on, left_on, ...])	合并 DataFrame 与另一个 DataFrame
DataFrame.min([axis, skipna, split_every, ...])	返回请求轴上值的最小值。
DataFrame.mod(other[, axis, level, fill_value])	获取数据框和其他对象的模数，逐元素操作（二元运算符 mod）。
DataFrame.mode([dropna, split_every, ...])	获取所选轴上每个元素的模式。
DataFrame.mul(other[, axis, level, fill_value])	获取数据框和其他对象的逐元素乘积（二元运算符 mul）。
DataFrame.ndim	返回维度
DataFrame.ne(other[, axis, level])	获取数据框和另一个数据框的元素不等式（二元运算符 ne）。
DataFrame.nlargest([n, columns, split_every])	返回按 columns 降序排列的前 n 行。
DataFrame.npartitions	返回分区数量
DataFrame.nsmallest([n, columns, split_every])	返回按 columns 升序排列的前 n 行。
DataFrame.partitions	按分区切片数据框
DataFrame.persist(**kwargs)	将此 dask 集合持久化到内存中
DataFrame.pivot_table([index, columns, ...])	创建一个电子表格样式的数据透视表作为DataFrame。
DataFrame.pop(item)	返回项目并从框架中移除。
DataFrame.pow(other[, axis, level, fill_value])	获取数据框和其他对象的指数幂，逐元素操作（二元运算符 pow）。
DataFrame.prod([axis, skipna, split_every, ...])	返回请求轴上值的乘积。
DataFrame.quantile([q, axis, numeric_only, ...])	DataFrame 的近似行方向和精确列方向的分位数
DataFrame.query(expr, **kwargs)	使用复杂表达式过滤数据框
DataFrame.radd(other[, axis, level, fill_value])	获取数据框与其他对象的逐元素相加结果（二元运算符 radd）。
DataFrame.random_split(frac[, random_state, ...])	伪随机地将数据框按行分割成不同的部分
DataFrame.rdiv(other[, axis, level, fill_value])	获取数据框和其他对象的浮点数除法，逐元素进行（二元运算符 rtruediv）。
DataFrame.reduction(chunk[, aggregate, ...])	通用行级归约。
DataFrame.rename([index, columns])	重命名列或索引标签。
DataFrame.repartition([divisions, ...])	沿新分区重新分区数据框
DataFrame.replace([to_replace, value, regex])	将 to_replace 中的值替换为 value。
DataFrame.resample(rule[, closed, label])	重采样时间序列数据。
DataFrame.reset_index([drop])	将索引重置为默认索引。
DataFrame.rfloordiv(other[, axis, level, ...])	获取数据框和其他对象的整数除法，逐元素进行（二元运算符 rfloordiv）。
DataFrame.rmod(other[, axis, level, fill_value])	获取数据框和其他对象的模数，逐元素进行（二元运算符 rmod）。
DataFrame.rmul(other[, axis, level, fill_value])	获取数据框和其他对象的逐元素乘积（二元运算符 rmul）。
DataFrame.round([decimals])	将 DataFrame 四舍五入到可变的小数位数。
DataFrame.rpow(other[, axis, level, fill_value])	获取数据框和其他元素的指数幂（二元运算符 rpow）。
DataFrame.rsub(other[, axis, level, fill_value])	获取数据框与其他对象的元素减法（二元运算符 rsub）。
DataFrame.rtruediv(other[, axis, level, ...])	获取数据框和其他对象的浮点数除法，逐元素进行（二元运算符 rtruediv）。
DataFrame.sample([n, frac, replace, ...])	随机样本项
DataFrame.select_dtypes([include, exclude])	根据列的数据类型返回DataFrame列的子集。
DataFrame.sem([axis, skipna, ddof, ...])	返回请求轴上的无偏标准误差。
DataFrame.set_index(other[, drop, sorted, ...])	使用现有列设置 DataFrame 索引（行标签）。
DataFrame.shape	返回一个表示 DataFrame 维度的元组。
DataFrame.shuffle(on[, npartitions, ...])	将 DataFrame 重新排列为新的分区
DataFrame.size	Series 或 DataFrame 的大小作为 Delayed 对象。
DataFrame.sort_values(by[, npartitions, ...])	按单列对数据集进行排序。
DataFrame.squeeze([axis])	将一维轴对象压缩为标量。
DataFrame.std([axis, skipna, ddof, ...])	返回请求轴上的样本标准差。
DataFrame.sub(other[, axis, level, fill_value])	获取数据框与其他对象的元素级减法（二元运算符 sub）。
DataFrame.sum([axis, skipna, split_every, ...])	返回请求轴上值的总和。
DataFrame.tail([n, compute])	数据集的最后 n 行
DataFrame.to_backend([backend])	切换到新的 DataFrame 后端
DataFrame.to_bag([index, format])	从 Dask DataFrame 创建 Dask Bag
DataFrame.to_csv(filename, **kwargs)	将 Dask DataFrame 存储为 CSV 文件
DataFrame.to_dask_array([lengths, meta])	将 dask DataFrame 转换为 dask 数组。
DataFrame.to_delayed([optimize_graph])	转换为一个 dask.delayed 对象列表，每个分区一个。
DataFrame.to_hdf(path_or_buf, key[, mode, ...])	将 Dask DataFrame 存储到分层数据格式 (HDF) 文件
DataFrame.to_html([max_rows])	将 DataFrame 渲染为 HTML 表格。
DataFrame.to_json(filename, *args, **kwargs)	更多信息请参见 dd.to_json 的文档字符串
DataFrame.to_parquet(path, *args, **kwargs)	将 Dask.dataframe 存储到 Parquet 文件
DataFrame.to_records([index, lengths])	从 Dask Dataframe 创建 Dask Array
DataFrame.to_string([max_rows])	将 DataFrame 渲染为控制台友好的表格输出。
DataFrame.to_sql(name, uri[, schema, ...])	有关更多信息，请参阅 dd.to_sql 的文档字符串
DataFrame.to_timestamp([freq, how, axis])	将时间戳转换为 DatetimeIndex，位于周期的 开始。
DataFrame.truediv(other[, axis, level, ...])	获取数据框和其他对象的浮点数除法，逐元素进行（二元运算符 truediv）。
DataFrame.values	返回此数据框值的 dask.array
DataFrame.var([axis, skipna, ddof, ...])	返回请求轴上的无偏方差。
DataFrame.visualize([filename, format, ...])	使用 graphviz 渲染此对象任务图的计算。
DataFrame.where(cond[, other])	替换条件为 False 的值。

系列

Series(dsk, name, meta, divisions)	并行 Pandas 系列
Series.add(other[, level, fill_value, axis])	返回序列和其他元素的加法，逐元素进行（二元运算符 add）。
Series.align(other[, join, axis, fill_value])	使用指定的连接方法将两个对象沿其轴对齐。
Series.all([axis, skipna, split_every, out])	返回是否所有元素都为 True，可能是在某个轴上。
Series.any([axis, skipna, split_every, out])	返回是否任何元素为 True，可能在某个轴上。
Series.apply(func[, convert_dtype, meta, args])	pandas.Series.apply 的并行版本
Series.astype(dtype)	将 pandas 对象转换为指定的数据类型 dtype。
Series.autocorr([lag, split_every])	计算滞后N的自相关。
Series.between(left, right[, inclusive])	返回布尔序列，等价于 left <= 序列 <= right。
Series.bfill([axis, limit])	使用下一个有效观测值来填充NA/NaN值。
Series.clear_divisions()	忘记部门信息
Series.clip([lower, upper, axis])	在输入阈值处修剪值。
Series.compute(**kwargs)	计算这个 dask 集合
Series.copy([deep])	复制数据框
Series.corr(other[, method, min_periods, ...])	计算与 other Series 的相关性，排除缺失值。
Series.count([split_every])	返回Series中非NA/null观测值的数量。
Series.cov(other[, min_periods, split_every])	计算与 Series 的协方差，排除缺失值。
Series.cummax([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最大值。
Series.cummin([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最小值。
Series.cumprod([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积乘积。
Series.cumsum([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积和。
Series.describe([split_every, percentiles, ...])	生成描述性统计数据。
Series.diff([periods, axis])	元素的第一次离散差分。
Series.div(other[, level, fill_value, axis])	返回序列和其他元素的浮点数除法，逐元素进行（二元运算符 truediv）。
Series.drop_duplicates([subset, ...])	返回删除了重复行的DataFrame。
Series.dropna()	返回一个移除了缺失值的新序列。
Series.dtype	返回数据类型
Series.eq(other[, level, fill_value, axis])	返回序列与其他元素逐项相等的比较结果（二元运算符 eq）。
Series.explode()	将类似列表的每个元素转换为一行。
Series.ffill([axis, limit])	通过将最后一个有效观测值传播到下一个有效值来填充 NA/NaN 值。
Series.fillna([value, method, limit, axis])	使用指定方法填充 NA/NaN 值。
Series.first(offset)	根据日期偏移选择时间序列数据的初始时间段。
Series.floordiv(other[, level, fill_value, axis])	返回序列和另一个序列的整数除法，逐元素进行（二元运算符 floordiv）。
Series.ge(other[, level, fill_value, axis])	返回序列和其他元素的“大于等于”比较结果，逐元素进行（二元运算符 ge）。
Series.get_partition(n)	获取表示第 nth 分区的 dask DataFrame/Series。
Series.groupby([by, group_keys, sort, ...])	使用映射器或通过一系列列来分组系列。
Series.gt(other[, level, fill_value, axis])	返回序列和其他元素逐项比较大于的结果（二元运算符 gt）。
Series.head([n, npartitions, compute])	数据集的前 n 行
Series.idxmax([axis, skipna, split_every, ...])	返回请求轴上最大值的第一个出现的索引。
Series.idxmin([axis, skipna, split_every, ...])	返回请求轴上最小值的首次出现的索引。
Series.isin(values)	Series 中的元素是否包含在 values 中。
Series.isna()	检测缺失值。
Series.isnull()	DataFrame.isnull 是 DataFrame.isna 的别名。
Series.known_divisions	分区是否已知
Series.last(offset)	根据日期偏移选择时间序列数据的最后时间段。
Series.le(other[, level, fill_value, axis])	返回序列和其他元素的“小于等于”比较结果，逐元素进行（二元运算符 le）。
Series.loc	纯标签位置索引器，用于按标签选择。
Series.lt(other[, level, fill_value, axis])	返回序列和另一个序列的逐元素小于比较结果（二元运算符 lt）。
Series.map(arg[, na_action, meta])	根据输入的映射或函数映射 Series 的值。
Series.map_overlap(func, before, after, ...)	对每个分区应用一个函数，与相邻分区共享行。
Series.map_partitions(func, *args, **kwargs)	在每个 DataFrame 分区上应用 Python 函数。
Series.mask(cond[, other])	替换条件为 True 的值。
Series.max([axis, skipna, split_every, out, ...])	返回请求轴上的值的最大值。
Series.mean([axis, skipna, split_every, ...])	返回请求轴上值的平均值。
Series.median([method])	返回请求轴上值的中位数。
Series.median_approximate([method])	返回请求轴上值的近似中位数。
Series.memory_usage([index, deep])	返回 Series 的内存使用情况。
Series.memory_usage_per_partition([index, deep])	返回每个分区的内存使用情况
Series.min([axis, skipna, split_every, out, ...])	返回请求轴上值的最小值。
Series.mod(other[, level, fill_value, axis])	返回序列和其他的模数，逐元素进行（二元运算符 mod）。
Series.mul(other[, level, fill_value, axis])	返回序列与其他对象的逐元素乘法（二元运算符 mul）。
Series.nbytes	字节数
Series.ndim	返回维度
Series.ne(other[, level, fill_value, axis])	返回序列与其他的元素不等价结果，逐元素操作（二元运算符 ne）。
Series.nlargest([n, split_every])	返回最大的 n 个元素。
Series.notnull()	DataFrame.notnull 是 DataFrame.notna 的别名。
Series.nsmallest([n, split_every])	返回最小的 n 个元素。
Series.nunique([split_every, dropna])	返回对象中唯一元素的数量。
Series.nunique_approx([split_every])	唯一行的近似数量。
Series.persist(**kwargs)	将此 dask 集合持久化到内存中
Series.pipe(func, *args, **kwargs)	应用期望 Series 或 DataFrame 的可链式函数。
Series.pow(other[, level, fill_value, axis])	返回序列和其他元素的指数幂（二元运算符 pow）。
Series.prod([axis, skipna, split_every, ...])	返回请求轴上值的乘积。
Series.quantile([q, method])	Series 的近似分位数
Series.radd(other[, level, fill_value, axis])	返回序列和其他元素的加法，逐元素进行（二元运算符 radd）。
Series.random_split(frac[, random_state, ...])	伪随机地将数据框按行分割成不同的部分
Series.rdiv(other[, level, fill_value, axis])	返回序列和其他的浮点数除法，逐元素进行（二元运算符 rtruediv）。
Series.reduction(chunk[, aggregate, ...])	通用行级归约。
Series.repartition([divisions, npartitions, ...])	沿新分区重新分区数据框
Series.replace([to_replace, value, regex])	将 to_replace 中的值替换为 value。
Series.rename([index, inplace, sorted_index])	修改系列索引标签或名称
Series.resample(rule[, closed, label])	重采样时间序列数据。
Series.reset_index([drop])	将索引重置为默认索引。
Series.rolling(window[, min_periods, ...])	提供滚动变换功能。
Series.round([decimals])	将 Series 中的每个值四舍五入到给定的位数。
Series.sample([n, frac, replace, random_state])	随机样本项
Series.sem([axis, skipna, ddof, ...])	返回请求轴上的无偏标准误差。
Series.shape	返回一个表示 Series 维度的元组。
Series.shift([periods, freq, axis])	通过可选的时间 freq 将索引按所需周期数进行移位。
Series.size	Series 或 DataFrame 的大小作为 Delayed 对象。
Series.std([axis, skipna, ddof, ...])	返回请求轴上的样本标准差。
Series.sub(other[, level, fill_value, axis])	返回序列和其他元素的减法结果，逐元素进行（二元运算符 sub）。
Series.sum([axis, skipna, split_every, ...])	返回请求轴上值的总和。
Series.to_backend([backend])	切换到新的 DataFrame 后端
Series.to_bag([index, format])	从 Series 创建一个 Dask Bag
Series.to_csv(filename, **kwargs)	将 Dask DataFrame 存储为 CSV 文件
Series.to_dask_array([lengths, meta])	将 dask DataFrame 转换为 dask 数组。
Series.to_delayed([optimize_graph])	转换为一个 dask.delayed 对象列表，每个分区一个。
Series.to_frame([name])	将 Series 转换为 DataFrame。
Series.to_hdf(path_or_buf, key[, mode, append])	将 Dask DataFrame 存储到分层数据格式 (HDF) 文件
Series.to_string([max_rows])	渲染 Series 的字符串表示。
Series.to_timestamp([freq, how, axis])	将时间戳转换为时间段的 开始 的 DatetimeIndex。
Series.truediv(other[, level, fill_value, axis])	返回序列和其他元素的浮点数除法，逐元素进行（二元运算符 truediv）。
Series.unique([split_every, split_out])	返回对象中的唯一值序列。
Series.value_counts([sort, ascending, ...])	返回一个包含唯一值计数的系列。
Series.values	返回此数据框值的 dask.array
Series.var([axis, skipna, ddof, ...])	返回请求轴上的无偏方差。
Series.visualize([filename, format, ...])	使用 graphviz 渲染此对象任务图的计算。
Series.where(cond[, other])	替换条件为 False 的值。

索引

Index(dsk, name, meta, divisions)
Index.add(other[, level, fill_value, axis])	返回序列和其他元素的加法，逐元素进行（二元运算符 add）。
Index.align(other[, join, axis, fill_value])	使用指定的连接方法将两个对象沿其轴对齐。
Index.all([axis, skipna, split_every, out])	返回是否所有元素都为 True，可能是在某个轴上。
Index.any([axis, skipna, split_every, out])	返回是否任何元素为 True，可能在某个轴上。
Index.apply(func[, convert_dtype, meta, args])	pandas.Series.apply 的并行版本
Index.astype(dtype)	将 pandas 对象转换为指定的数据类型 dtype。
Index.autocorr([lag, split_every])	计算滞后N的自相关。
Index.between(left, right[, inclusive])	返回布尔序列，等价于 left <= 序列 <= right。
Index.bfill([axis, limit])	使用下一个有效观测值来填充NA/NaN值。
Index.clear_divisions()	忘记部门信息
Index.clip([lower, upper, axis])	在输入阈值处修剪值。
Index.compute(**kwargs)	计算这个 dask 集合
Index.copy([deep])	复制数据框
Index.corr(other[, method, min_periods, ...])	计算与 other Series 的相关性，排除缺失值。
Index.count([split_every])	返回Series中非NA/null观测值的数量。
Index.cov(other[, min_periods, split_every])	计算与 Series 的协方差，排除缺失值。
Index.cummax([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最大值。
Index.cummin([axis, skipna, out])	返回 DataFrame 或 Series 轴上的累积最小值。
Index.cumprod([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积乘积。
Index.cumsum([axis, skipna, dtype, out])	返回 DataFrame 或 Series 轴上的累积和。
Index.describe([split_every, percentiles, ...])	生成描述性统计数据。
Index.diff([periods, axis])	元素的第一次离散差分。
Index.div(other[, level, fill_value, axis])	返回序列和其他元素的浮点数除法，逐元素进行（二元运算符 truediv）。
Index.drop_duplicates([split_every, ...])	返回删除了重复值的索引。
Index.dropna()	返回一个移除了缺失值的新序列。
Index.dtype	返回数据类型
Index.eq(other[, level, fill_value, axis])	返回序列与其他元素逐项相等的比较结果（二元运算符 eq）。
Index.explode()	将类似列表的每个元素转换为一行。
Index.ffill([axis, limit])	通过将最后一个有效观测值传播到下一个有效值来填充 NA/NaN 值。
Index.fillna([value, method, limit, axis])	使用指定方法填充 NA/NaN 值。
Index.first(offset)	根据日期偏移选择时间序列数据的初始时间段。
Index.floordiv(other[, level, fill_value, axis])	返回序列和另一个序列的整数除法，逐元素进行（二元运算符 floordiv）。
Index.ge(other[, level, fill_value, axis])	返回序列和其他元素的“大于等于”比较结果，逐元素进行（二元运算符 ge）。
Index.get_partition(n)	获取表示第 nth 分区的 dask DataFrame/Series。
Index.groupby([by, group_keys, sort, ...])	使用映射器或通过一系列列来分组系列。
Index.gt(other[, level, fill_value, axis])	返回序列和其他元素逐项比较大于的结果（二元运算符 gt）。
Index.head([n, compute])	索引的前 n 项。
Index.idxmax([axis, skipna, split_every, ...])	返回请求轴上最大值的第一个出现的索引。
Index.idxmin([axis, skipna, split_every, ...])	返回请求轴上最小值的首次出现的索引。
Index.is_monotonic_decreasing	如果值相等或递减，则返回布尔值。
Index.is_monotonic_increasing	如果值相等或递增，则返回布尔值。
Index.isin(values)	Series 中的元素是否包含在 values 中。
Index.isna()	检测缺失值。
Index.isnull()	DataFrame.isnull 是 DataFrame.isna 的别名。
Index.known_divisions	分区是否已知
Index.last(offset)	根据日期偏移选择时间序列数据的最后时间段。
Index.le(other[, level, fill_value, axis])	返回序列和其他元素的“小于等于”比较结果，逐元素进行（二元运算符 le）。
Index.loc	纯标签位置索引器，用于按标签选择。
Index.lt(other[, level, fill_value, axis])	返回序列和另一个序列的逐元素小于比较结果（二元运算符 lt）。
Index.map(arg[, na_action, meta, is_monotonic])	使用输入映射或函数映射值。
Index.map_overlap(func, before, after, ...)	对每个分区应用一个函数，与相邻分区共享行。
Index.map_partitions(func, *args, **kwargs)	在每个 DataFrame 分区上应用 Python 函数。
Index.mask(cond[, other])	替换条件为 True 的值。
Index.max([split_every])	返回索引的最大值。
Index.mean([axis, skipna, split_every, ...])	返回请求轴上值的平均值。
Index.median([method])	返回请求轴上值的中位数。
Index.median_approximate([method])	返回请求轴上值的近似中位数。
Index.memory_usage([deep])	值的内存使用情况。
Index.memory_usage_per_partition([index, deep])	返回每个分区的内存使用情况
Index.min([split_every])	返回索引的最小值。
Index.mod(other[, level, fill_value, axis])	返回序列和其他的模数，逐元素进行（二元运算符 mod）。
Index.mul(other[, level, fill_value, axis])	返回序列与其他对象的逐元素乘法（二元运算符 mul）。
Index.nbytes	字节数
Index.ndim	返回维度
Index.ne(other[, level, fill_value, axis])	返回序列与其他的元素不等价结果，逐元素操作（二元运算符 ne）。
Index.nlargest([n, split_every])	返回最大的 n 个元素。
Index.notnull()	DataFrame.notnull 是 DataFrame.notna 的别名。
Index.nsmallest([n, split_every])	返回最小的 n 个元素。
Index.nunique([split_every, dropna])	返回对象中唯一元素的数量。
Index.nunique_approx([split_every])	唯一行的近似数量。
Index.persist(**kwargs)	将此 dask 集合持久化到内存中
Index.pipe(func, *args, **kwargs)	应用期望 Series 或 DataFrame 的可链式函数。
Index.pow(other[, level, fill_value, axis])	返回序列和其他元素的指数幂（二元运算符 pow）。
Index.prod([axis, skipna, split_every, ...])	返回请求轴上值的乘积。
Index.quantile([q, method])	Series 的近似分位数
Index.radd(other[, level, fill_value, axis])	返回序列和其他元素的加法，逐元素进行（二元运算符 radd）。
Index.random_split(frac[, random_state, shuffle])	伪随机地将数据框按行分割成不同的部分
Index.rdiv(other[, level, fill_value, axis])	返回序列和其他的浮点数除法，逐元素进行（二元运算符 rtruediv）。
Index.reduction(chunk[, aggregate, combine, ...])	通用行级归约。
Index.rename([index, inplace, sorted_index])	修改系列索引标签或名称
Index.repartition([divisions, npartitions, ...])	沿新分区重新分区数据框
Index.replace([to_replace, value, regex])	将 to_replace 中的值替换为 value。
Index.resample(rule[, closed, label])	重采样时间序列数据。
Index.reset_index([drop])	将索引重置为默认索引。
Index.rolling(window[, min_periods, center, ...])	提供滚动变换功能。
Index.round([decimals])	将 Series 中的每个值四舍五入到给定的位数。
Index.sample([n, frac, replace, random_state])	随机样本项
Index.sem([axis, skipna, ddof, split_every, ...])	返回请求轴上的无偏标准误差。
Index.shape	返回一个表示 Series 维度的元组。
Index.shift([periods, freq])	按所需的时间频率增量数移动索引。
Index.size	Series 或 DataFrame 的大小作为 Delayed 对象。
Index.std([axis, skipna, ddof, split_every, ...])	返回请求轴上的样本标准差。
Index.sub(other[, level, fill_value, axis])	返回序列和其他元素的减法结果，逐元素进行（二元运算符 sub）。
Index.sum([axis, skipna, split_every, ...])	返回请求轴上值的总和。
Index.to_backend([backend])	切换到新的 DataFrame 后端
Index.to_bag([index, format])	从 Series 创建一个 Dask Bag
Index.to_csv(filename, **kwargs)	将 Dask DataFrame 存储为 CSV 文件
Index.to_dask_array([lengths, meta])	将 dask DataFrame 转换为 dask 数组。
Index.to_delayed([optimize_graph])	转换为一个 dask.delayed 对象列表，每个分区一个。
Index.to_frame([index, name])	创建一个包含索引列的DataFrame。
Index.to_hdf(path_or_buf, key[, mode, append])	将 Dask DataFrame 存储到分层数据格式 (HDF) 文件
Index.to_series()	创建一个索引和值都等于索引键的系列。
Index.to_string([max_rows])	渲染 Series 的字符串表示。
Index.to_timestamp([freq, how, axis])	将时间戳转换为时间段的 开始 的 DatetimeIndex。
Index.truediv(other[, level, fill_value, axis])	返回序列和其他元素的浮点数除法，逐元素进行（二元运算符 truediv）。
Index.unique([split_every, split_out])	返回对象中的唯一值序列。
Index.value_counts([sort, ascending, ...])	返回一个包含唯一值计数的系列。
Index.values	返回此数据框值的 dask.array
Index.var([axis, skipna, ddof, split_every, ...])	返回请求轴上的无偏方差。
Index.visualize([filename, format, ...])	使用 graphviz 渲染此对象任务图的计算。
Index.where(cond[, other])	替换条件为 False 的值。
Index.to_frame([index, name])	创建一个包含索引列的DataFrame。

访问器

与 pandas 类似，Dask 在各种访问器下提供了特定于数据类型的方法。这些是 Series 中的独立命名空间，仅适用于特定的数据类型。

Datetime 访问器

方法

Series.dt.ceil(*args, **kwargs)	对数据执行 ceil 操作到指定的 freq。
Series.dt.floor(*args, **kwargs)	对数据执行向下取整操作到指定的 freq。
Series.dt.isocalendar()	根据 ISO 8601 标准计算年、周和日。
Series.dt.normalize(*args, **kwargs)	将时间转换为午夜。
Series.dt.round(*args, **kwargs)	对数据执行四舍五入操作到指定的 freq。
Series.dt.strftime(*args, **kwargs)	使用指定的 date_format 转换为索引。

属性

Series.dt.date	返回包含 Python datetime.date 对象的 numpy 数组。
Series.dt.day	datetime 的日期部分。
Series.dt.dayofweek	一周中的某一天，其中星期一=0，星期日=6。
Series.dt.dayofyear	一年中的第几天。
Series.dt.daysinmonth	该月份的天数。
Series.dt.freq
Series.dt.hour	datetime 的小时数
Series.dt.microsecond	datetime 的微秒部分。
Series.dt.minute	datetime 的分钟数
Series.dt.month	月份表示为 一月=1, 十二月=12。
Series.dt.nanosecond	datetime 的纳秒部分。
Series.dt.quarter	日期的季度。
Series.dt.second	datetime 的秒数。
Series.dt.time	返回 datetime.time 对象的 numpy 数组。
Series.dt.timetz	返回包含时区的 datetime.time 对象的 numpy 数组。
Series.dt.tz	返回时区。
Series.dt.week	一年中的周序数。
Series.dt.weekday	一周中的某一天，其中星期一=0，星期日=6。
Series.dt.weekofyear	一年中的周序数。
Series.dt.year	datetime 的年份

字符串访问器

方法

Series.str.capitalize()	将 Series/Index 中的字符串转换为大写。
Series.str.casefold()	将 Series/Index 中的字符串转换为大小写折叠。
Series.str.cat([others, sep, na_rep])	在 Series/Index 中使用给定的分隔符连接字符串。
Series.str.center(width[, fillchar])	在 Series/Index 中的字符串的左右两侧填充。
Series.str.contains(pat[, case, flags, na, ...])	测试模式或正则表达式是否包含在 Series 或 Index 的字符串中。
Series.str.count(pat[, flags])	计算 Series/Index 中每个字符串中模式的出现次数。
Series.str.decode(encoding[, errors])	使用指定的编码解码Series/Index中的字符串。
Series.str.encode(encoding[, errors])	使用指定的编码对 Series/Index 中的字符串进行编码。
Series.str.endswith(*args, **kwargs)	测试每个字符串元素的末尾是否匹配某个模式。
Series.str.extract(*args, **kwargs)	在正则表达式 pat 中提取捕获组作为 DataFrame 中的列。
Series.str.extractall(pat[, flags])	在 DataFrame 中提取正则表达式 pat 中的捕获组作为列。
Series.str.find(sub[, start, end])	返回 Series/Index 中每个字符串中的最低索引。
Series.str.findall(pat[, flags])	在 Series/Index 中查找所有模式或正则表达式的出现。
Series.str.fullmatch(pat[, case, flags, na])	确定每个字符串是否完全匹配正则表达式。
Series.str.get(i)	从指定位置或指定键的每个组件中提取元素。
Series.str.index(sub[, start, end])	返回 Series/Index 中每个字符串中的最低索引。
Series.str.isalnum()	检查每个字符串中的所有字符是否都是字母数字。
Series.str.isalpha()	检查每个字符串中的所有字符是否均为字母。
Series.str.isdecimal()	检查每个字符串中的所有字符是否为十进制。
Series.str.isdigit()	检查每个字符串中的所有字符是否都是数字。
Series.str.islower()	检查每个字符串中的所有字符是否均为小写。
Series.str.isnumeric()	检查每个字符串中的所有字符是否都是数字。
Series.str.isspace()	检查每个字符串中的所有字符是否均为空白字符。
Series.str.istitle()	检查每个字符串中的所有字符是否为标题大小写。
Series.str.isupper()	检查每个字符串中的所有字符是否均为大写。
Series.str.join(sep)	使用传递的分隔符连接作为 Series/Index 元素的列表。
Series.str.len()	计算 Series/Index 中每个元素的长度。
Series.str.ljust(width[, fillchar])	在 Series/Index 中对字符串的右侧进行填充。
Series.str.lower()	将 Series/Index 中的字符串转换为小写。
Series.str.lstrip([to_strip])	移除前导字符。
Series.str.match(pat[, case, flags, na])	确定每个字符串是否以正则表达式的匹配项开头。
Series.str.normalize(form)	返回 Series/Index 中字符串的 Unicode 规范化形式。
Series.str.pad(width[, side, fillchar])	将 Series/Index 中的字符串填充到指定宽度。
Series.str.partition([sep, expand])	在 sep 的第一次出现处拆分字符串。
Series.str.repeat(repeats)	在 Series 或 Index 中重复每个字符串。
Series.str.replace(pat, repl[, n, case, ...])	替换 Series/Index 中每个出现的模式/正则表达式。
Series.str.rfind(sub[, start, end])	返回 Series/Index 中每个字符串中的最高索引。
Series.str.rindex(sub[, start, end])	返回Series/Index中每个字符串中的最高索引。
Series.str.rjust(width[, fillchar])	在 Series/Index 中的字符串左侧填充。
Series.str.rpartition([sep, expand])	在 sep 的最后一次出现处拆分字符串。
Series.str.rsplit([pat, n, expand])	根据给定的分隔符/定界符拆分字符串。
Series.str.rstrip([to_strip])	移除尾随字符。
Series.str.slice([start, stop, step])	从 Series 或 Index 中的每个元素中切片子字符串。
Series.str.split([pat, n, expand])	根据给定的分隔符/定界符拆分字符串。
Series.str.startswith(*args, **kwargs)	测试每个字符串元素的开头是否匹配某个模式。
Series.str.strip([to_strip])	移除前导和尾随字符。
Series.str.swapcase()	将 Series/Index 中的字符串转换为交换大小写。
Series.str.title()	将 Series/Index 中的字符串转换为首字母大写。
Series.str.translate(table)	通过给定的映射表映射字符串中的所有字符。
Series.str.upper()	将 Series/Index 中的字符串转换为大写。
Series.str.wrap(width, **kwargs)	在指定的行宽处对 Series/Index 中的字符串进行换行。
Series.str.zfill(width)	在 Series/Index 中的字符串前添加 '0' 字符进行填充。

分类访问器

方法

Series.cat.add_categories(*args, **kwargs)	添加新类别。
Series.cat.as_known(**kwargs)	确保本系列中的类别是已知的。
Series.cat.as_ordered(*args, **kwargs)	将类别设置为有序。
Series.cat.as_unknown()	确保本系列中的类别是未知的
Series.cat.as_unordered(*args, **kwargs)	将分类设置为无序。
Series.cat.remove_categories(*args, **kwargs)	移除指定的类别。
Series.cat.remove_unused_categories()	移除未使用的类别
Series.cat.rename_categories(*args, **kwargs)	重命名类别。
Series.cat.reorder_categories(*args, **kwargs)	按照 new_categories 中的指定重新排序类别。
Series.cat.set_categories(*args, **kwargs)	将类别设置为指定的新类别。

属性

Series.cat.categories	这个分类的类别。
Series.cat.codes	这个类别的代码。
Series.cat.known	类别是否完全已知
Series.cat.ordered	类别是否具有有序关系

分组操作

DataFrame 分组

DataFrameGroupBy.aggregate([arg, ...])	使用一个或多个指定的操作进行聚合
DataFrameGroupBy.apply(func, *args, **kwargs)	pandas GroupBy.apply 的并行版本
DataFrameGroupBy.bfill([limit])	向后填充值。
DataFrameGroupBy.count([split_every, ...])	计算组的数量，排除缺失值。
DataFrameGroupBy.cumcount([axis])	每个组中的每一项从0到该组长度减1进行编号。
DataFrameGroupBy.cumprod([axis, numeric_only])	每个组的累积乘积。
DataFrameGroupBy.cumsum([axis, numeric_only])	每个组的累计和。
DataFrameGroupBy.fillna([value, method, ...])	使用指定方法填充 NA/NaN 值。
DataFrameGroupBy.ffill([limit])	向前填充值。
DataFrameGroupBy.get_group(key)	从具有提供名称的组构造 DataFrame。
DataFrameGroupBy.max([split_every, ...])	计算组值的最大值。
DataFrameGroupBy.mean([split_every, ...])	计算各组的均值，排除缺失值。
DataFrameGroupBy.min([split_every, ...])	计算组值的最小值。
DataFrameGroupBy.size([split_every, ...])	计算组大小。
DataFrameGroupBy.std([ddof, split_every, ...])	计算组的样本标准差，排除缺失值。
DataFrameGroupBy.sum([split_every, ...])	计算组值的总和。
DataFrameGroupBy.var([ddof, split_every, ...])	计算各组的方差，排除缺失值。
DataFrameGroupBy.cov([ddof, split_every, ...])	计算列之间的成对协方差，排除NA/空值。
DataFrameGroupBy.corr([ddof, split_every, ...])	计算列之间的成对相关性，排除NA/null值。
DataFrameGroupBy.first([split_every, ...])	计算每个组内每一列的第一个条目。
DataFrameGroupBy.last([split_every, ...])	计算每个组内每一列的最后一个条目。
DataFrameGroupBy.idxmin([split_every, ...])	返回请求轴上最小值的首次出现的索引。
DataFrameGroupBy.idxmax([split_every, ...])	返回请求轴上最大值的第一个出现的索引。
DataFrameGroupBy.rolling(window[, ...])	提供滚动变换功能。
DataFrameGroupBy.transform(func, *args, **kwargs)	pandas GroupBy.transform 的并行版本

Series 分组

SeriesGroupBy.aggregate([arg, split_every, ...])	使用一个或多个指定的操作进行聚合
SeriesGroupBy.apply(func, *args, **kwargs)	pandas GroupBy.apply 的并行版本
SeriesGroupBy.bfill([limit])	向后填充值。
SeriesGroupBy.count([split_every, ...])	计算组的数量，排除缺失值。
SeriesGroupBy.cumcount([axis])	每个组中的每一项从0到该组长度减1进行编号。
SeriesGroupBy.cumprod([axis, numeric_only])	每个组的累积乘积。
SeriesGroupBy.cumsum([axis, numeric_only])	每个组的累计和。
SeriesGroupBy.fillna([value, method, limit, ...])	使用指定方法填充 NA/NaN 值。
SeriesGroupBy.ffill([limit])	向前填充值。
SeriesGroupBy.get_group(key)	从具有提供名称的组构造 DataFrame。
SeriesGroupBy.max([split_every, split_out, ...])	计算组值的最大值。
SeriesGroupBy.mean([split_every, split_out, ...])	计算各组的均值，排除缺失值。
SeriesGroupBy.min([split_every, split_out, ...])	计算组值的最小值。
SeriesGroupBy.nunique([split_every, split_out])	返回组中唯一元素的数量。
SeriesGroupBy.size([split_every, split_out, ...])	计算组大小。
SeriesGroupBy.std([ddof, split_every, ...])	计算组的样本标准差，排除缺失值。
SeriesGroupBy.sum([split_every, split_out, ...])	计算组值的总和。
SeriesGroupBy.var([ddof, split_every, ...])	计算各组的方差，排除缺失值。
SeriesGroupBy.first([split_every, ...])	计算每个组内每一列的第一个条目。
SeriesGroupBy.last([split_every, split_out, ...])	计算每个组内每一列的最后一个条目。
SeriesGroupBy.idxmin([split_every, ...])	返回请求轴上最小值的首次出现的索引。
SeriesGroupBy.idxmax([split_every, ...])	返回请求轴上最大值的第一个出现的索引。
SeriesGroupBy.rolling(window[, min_periods, ...])	提供滚动变换功能。
SeriesGroupBy.transform(func, *args, **kwargs)	pandas GroupBy.transform 的并行版本

自定义聚合

Aggregation(name, chunk, agg[, finalize])

用户定义的分组聚合。

滚动操作

map_overlap(func, df, before, after, *args)	对每个分区应用一个函数，与相邻分区共享行。
Series.rolling(window[, min_periods, ...])	提供滚动变换功能。
DataFrame.rolling(window[, min_periods, ...])	提供滚动变换功能。

Rolling.apply(func[, raw, engine, ...])	计算滚动自定义聚合函数。
Rolling.count()	计算非 NaN 观测值的滚动计数。
Rolling.kurt()	计算无偏的滚动Fisher峰度定义。
Rolling.max()	计算滚动最大值。
Rolling.mean()	计算滚动平均值。
Rolling.median()	计算滚动中位数。
Rolling.min()	计算滚动最小值。
Rolling.quantile(quantile)	计算滚动分位数。
Rolling.skew()	计算滚动无偏斜度。
Rolling.std([ddof])	计算滚动标准差。
Rolling.sum()	计算滚动总和。
Rolling.var([ddof])	计算滚动方差。

创建数据框

read_csv(urlpath[, blocksize, ...])	将 CSV 文件读入 Dask.DataFrame
read_table(urlpath[, blocksize, ...])	将分隔文件读入 Dask.DataFrame
read_fwf(urlpath[, blocksize, ...])	将固定宽度的文件读入 Dask.DataFrame
read_parquet(path[, columns, filters, ...])	将 Parquet 文件读取到 Dask DataFrame 中
read_hdf(pattern, key[, start, stop, ...])	将 HDF 文件读取到 Dask DataFrame 中
read_json(url_path[, orient, lines, ...])	从一组JSON文件创建一个数据框
read_orc(path[, engine, columns, index, ...])	从 ORC 文件中读取数据框
read_sql_table(table_name, con, index_col[, ...])	将 SQL 数据库表读取到 DataFrame 中。
read_sql_query(sql, con, index_col[, ...])	将 SQL 查询读取到 DataFrame 中。
read_sql(sql, con, index_col, **kwargs)	将 SQL 查询或数据库表读取到 DataFrame 中。
from_array(x[, chunksize, columns, meta])	将任何可切片数组读入 Dask 数据框
from_dask_array(x[, columns, index, meta])	从 Dask 数组创建一个 Dask DataFrame。
from_delayed(dfs[, meta, divisions, prefix, ...])	从许多 Dask Delayed 对象创建 Dask DataFrame。
from_map(func, *iterables[, args, meta, ...])	从自定义函数映射创建一个 DataFrame 集合。
from_pandas()	从 Pandas DataFrame 构建 Dask DataFrame
DataFrame.from_dict(data, *, npartitions[, ...])	从 Python 字典构建 Dask DataFrame

Bag.to_dataframe([meta, columns, optimize_graph])

从 Dask Bag 创建 Dask Dataframe。

存储数据框

to_csv(df, filename[, single_file, ...])	将 Dask DataFrame 存储为 CSV 文件
to_parquet(df, path[, engine, compression, ...])	将 Dask.dataframe 存储到 Parquet 文件
to_hdf(df, path, key[, mode, append, ...])	将 Dask DataFrame 存储到分层数据格式 (HDF) 文件
to_records(df)	从 Dask Dataframe 创建 Dask Array
to_sql(df, name, uri[, schema, if_exists, ...])	将 Dask 数据框存储到 SQL 表中
to_json(df, url_path[, orient, lines, ...])	将数据框写入 JSON 文本文件

转换数据框

DataFrame.to_bag([index, format])	从 Dask DataFrame 创建 Dask Bag
DataFrame.to_dask_array([lengths, meta])	将 dask DataFrame 转换为 dask 数组。
DataFrame.to_delayed([optimize_graph])	转换为一个 dask.delayed 对象列表，每个分区一个。

重塑 DataFrame

get_dummies(data[, prefix, prefix_sep, ...])	将分类变量转换为哑变量/指示变量。
pivot_table(df[, index, columns, values, ...])	创建一个电子表格样式的数据透视表作为DataFrame。
melt(frame[, id_vars, value_vars, var_name, ...])	将 DataFrame 从宽格式透视为长格式，可以选择保留标识变量集。

连接DataFrame

DataFrame.merge(right[, how, on, left_on, ...])	合并 DataFrame 与另一个 DataFrame
concat(dfs[, axis, join, ...])	沿行方向连接DataFrame。
merge(left, right[, how, on, left_on, ...])	使用数据库风格的连接合并 DataFrame 或命名 Series 对象。
merge_asof(left, right[, on, left_on, ...])	按键距离执行合并。

重采样

Resampler(obj, rule, **kwargs)	用于重采样时间序列数据的类。
Resampler.agg(agg_funcs, *args, **kwargs)	在指定的轴上使用一个或多个操作进行聚合。
Resampler.count()	计算组的数量，排除缺失值。
Resampler.first()	计算每个组内每一列的第一个条目。
Resampler.last()	计算每个组内每一列的最后一个条目。
Resampler.max()	计算组的最大值。
Resampler.mean()	计算各组的均值，排除缺失值。
Resampler.median()	计算各组的中位数，排除缺失值。
Resampler.min()	计算组的最小值。
Resampler.nunique()	返回组中唯一元素的数量。
Resampler.ohlc()	计算一组数据的开盘、最高、最低和收盘值，排除缺失值。
Resampler.prod()	计算组值的乘积。
Resampler.quantile()	返回给定分位数的值。
Resampler.sem()	计算各组均值的标准误差，排除缺失值。
Resampler.size()	计算组大小。
Resampler.std()	计算组的样本标准差，排除缺失值。
Resampler.sum()	计算组值的总和。
Resampler.var()	计算各组的方差，排除缺失值。

Dask 元数据

make_meta(x[, index, parent_meta])

此方法根据 x 的类型创建元数据，如果提供了 parent_meta ，则使用它。

其他功能

compute(*args[, traverse, optimize_graph, ...])	一次计算多个 dask 集合。
map_partitions(func, *args[, meta, ...])	在每个 DataFrame 分区上应用 Python 函数。
to_datetime()	将参数转换为日期时间。
to_numeric(arg[, errors, meta])	将参数转换为数值类型。
to_timedelta()	将参数转换为 timedelta。

上一页

使用 Dask 进行 Hive 分区

下一页

dask.dataframe.DataFrame