文档首页/ 智能数据湖 AI DataLake/ SDK参考/ 引擎专属SDK/ Python SDK参考/ Aura DataFrame SDK（Python）/ Dataset APIs

更新时间：2026-10-16 GMT+08:00

Dataset APIs

columns

描述：获取Dataset的所有列的列名集合。

语法格式：

columns()

输入参数：无

返回值类型：tuple[str, ...]

示例：

>>> from aura_frame.multimodal import ai_lake 
>>> con = ai_lake.connect( 
...     aura_endpoint='*', 
...     access_key='*', 
...     secret_key='*' 
...     
... 
... ) 
>>> ds = con.load_dataset("demo_table_10", database='my_schema') 
>>> ds.columns 
('species',
  'island',
  'bill_length_mm',
  'bill_depth_mm',  'flipper_length_mm')

add_column

描述：给一个Dataset添加列。

语法格式：

add_column(*exprs, **mutations)

输入参数：

参数	是否必选	参数类型	描述
exprs	否	Union[Sequence[Expr], None]	要添加为列的命名表达式序列。
mutations	否	Value	使用关键字参数的命名表达式。

返回值类型：已添加新列的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake 
>>> con = ai_lake.connect( 
...     aura_endpoint='*', 
...     access_key='*' 
...     secret_key='*' 
...     ... 
... ) 
>>> ds = con.load_dataset("demo_table_6", database='my_schema') 
>>> ds 
| species | bill_length_mm |
| ------- | -------------- |
| string  | float64        |
| ------- | -------------- |
| Adelie  | 40.0           |
| Adelie  | 41.0           |
| Adelie  | 42.0           |
| Adelie  | 43.0           |

#Add a new column from a per-element expression
>>> ds.add_column(new_col=ds.bill_length_mm + 1)
| species | bill_length_mm | new_col  |
| ------- | -------------- | -------- |
| string  | float64        | float64  |
| ------- | -------------- | -------- |
| Adelie  | 40.0           | 41.0     |
| Adelie  | 41.0           | 42.0     |
| Adelie  | 42.0           | 43.0     |
| Adelie  | 43.0           | 44.0     |

drop_columns

描述：删除Dataset的列。

语法格式：

drop_columns(*fields)

输入参数：

参数	是否必选	参数类型	描述
fields	是	str	被删除列的列名。

返回值类型：删除列后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_12", database='my_schema')
>>> ds
| species | island    | bill_length_mm | bill_depth_mm | flipper_length_mm |
| ------- | --------- | -------------- | ------------- | ----------------- |
| string  | string    | float64        | float64       | int64             |
| ------- | --------- | -------------- | ------------- | ----------------- |
| Adelie  | Torgersen | 40.0           | 22.0          | 180               |
| Adelie  | Torgersen | 41.0           | 19.0          | 183               |
| Adelie  | Torgersen | 42.0           | 20.0          | 190               |
| Adelie  | Torgersen | 43.0           | 23.0          | 185               |

# Drop one or more columns
>>> ds.drop_columns("species")
| island    | bill_length_mm | bill_depth_mm | flipper_length_mm |
| --------- | -------------- | ------------- | ----------------- |
| string    | float64        | float64       | int64             |
| --------- | -------------- | ------------- | ----------------- |
| Torgersen | 40.0           | 22.0          | 180               |
| Torgersen | 41.0           | 19.0          | 183               |
| Torgersen | 42.0           | 20.0          | 190               |
| Torgersen | 43.0           | 23.0          | 185               |

aggregate

描述：通过指定分组字段，用一组聚合函数对数据集进行聚合。

语法格式：

aggregate(metrics=(), /, *, by=(), having=(), **kwargs)

输入参数：

参数	是否必选	参数类型	描述
metrics	否	Union[Sequence[AggregateFnBuilder], None]	聚合表达式，这类表达式可以是任何能生成标量值的表达式，其中包括聚合函数，例如sum。
by	否	Union[Sequence[Value], None]	分组表达式，一般设为Dataset的列名集合。
having	否	Union[Sequence[BooleanValue], None]	聚合后过滤器。其数据维度应该与metrics相同，且having（子句）的输出类型为布尔型。
kwargs	否	-	命名的聚合表达式。

返回值类型：聚合后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_13", database='my_schema')
>>> ds
| fruit  | price |
| ------ | ----- |
| apple  | 0.50  |
| apple  | 0.50  |
| banana | 0.25  |
| orange | 0.33  |
>>> ds.aggregate(
...     by=["fruit"],
...     total_cost=ds.price.sum(),
...     avg_cost=ds.price.mean(),
...     having=ds.price.sum() < 0.5,
... ).order_by("fruit")
| fruit  | total_cost | avg_cost |
| ------ | ---------- | -------- |
| string | float64    | float64  |
| ------ | ---------- | -------- |
| banana | 0.25       | 0.25     |
| orange | 0.33       | 0.33     |

count

描述：计算该Dataset的总行数。

语法格式：

count()

输入参数：无

返回值类型：int

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_11", database='my_schema')
>>> ds
| a     |
| ----- |
| string|
| ----- |
| foo   |
| bar   |
| baz   |
>>> ds.count()
┌─┐
│ 3│
└─┘

execute

描述：执行表达式。

语法格式：

execute(*, limit='default', params=None,  block=False, **kwargs)

输入参数：

参数	是否必选	参数类型	描述
limit	否	Union[int, str, None]	限定表达式执行结果的总行数。
params	否	Union[Mapping[Value, Any], None]	标量参数表达式到值的映射。
block	否	bool	表示是否异步执行，若为True，就返回AsyncJob对象。
kwargs	否	-	关键字参数

返回值类型：Union[pandas.DataFrame, pandas.Series, AsyncJob ,Any]

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_8", database='my_schema')
>>> ds.execute()
       a     b
0      1     c
1      1     a
2      2     a
[3 rows x 2 columns]

filter

描述：过滤掉不满足条件的行。

语法格式：

filter(expr=None, fn=None, on=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)

输入参数：

参数	是否必选	参数类型	描述
expr	否	Union[list[ir.BooleanValue], Sequence[ir.BooleanValue], IfAnyAll, None]	表达式字符串，需为有效的Python表达式。
on	否	Union[str, list[str]]	用于应用函数的列。
fn	否	Union[str, Callable, None]	可调用的函数，或函数名称。
num_cpus	否	Union[float, None]	CPU的数量。
memory	否	Union[int, None]	内存大小，单位为MB。
arch	否	Union[str, None]	架构类型，参数值为x86或arm。
device	否	Union[str, None]	AI处理单元的类型名，参数值为NPU或GPU。
model	否	Union[str, None]	AI处理单元型号，例如910B、A100等。
num_models	否	Union[float, None]	AI处理单元的数量，仅NPU和GPU支持配置。
concurrency	否	Union[int, Tuple[int, int], None]	函数执行时的并发度。
fn_constructor_kwargs	否	-	构造参数，只有当fn为可调用类时，才能提供此项。

返回值类型：过滤掉不满足条件的行后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_3", database='my_schema')
>>> ds = ds.filter(expr=[ds.a < 2])
>>> ds
| a     | b     |
| ----- | ----- |
| int64 | string|
| ----- | ----- |
| 1     | c     |
| 1     | a     |

# Filtered by User-defined functions
# my_schema.id_filter:inputting an int value, returning false if value is larger than 2.
>>> ds = con.load_dataset("demo_table_2", database='my_schema')
>>> ds = ds.filter(
...     fn='my_schema.id_filter',
...     on='a',
... )
>>> ds
| a     | b     |
| ----- | ----- |
| int64 | string|
| ----- | ----- |
| 1     | c     |
| 1     | a     |

flat_map

描述：将给定的函数应用于每一行，并对结果进行展平。

语法格式：

flat_map(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)

输入参数：

参数	是否必选	参数类型	描述
fn	是	Union[str, Callable]	可调用的函数或其名称，例如myschema.myfunction。
on	是	Union[str, list[str], ]	要应用函数的列或列的集合。
as_col	否	Union[str, list[str], None]	输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。
num_cpus	否	Union[float, None]	CPU的数量。
memory	否	Union[int, None]	内存大小，单位为MB。
arch	否	Union[str, None]	架构类型，参数值为x86或arm。
device	否	Union[str, None]	AI处理单元的类型名，参数值为NPU或GPU。
model	否	Union[str, None]	AI处理单元型号，例如910B、A100等。
num_models	否	Union[float, None]	AI处理单元的数量，仅NPU和GPU支持配置。
concurrency	否	Union[int, Tuple[int, int], None]	函数执行时的并发度。
fn_constructor_kwargs	否	-	构造参数，只有当fn为可调用类时，才能提供此项。

返回值类型：

Dataset ：调用函数后包含名为as_col的新列的数据集。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_2", database='my_schema')
>>> ds.execute()
       a     b     c
0      1     4     1
[1 rows x 3 columns]

>>> ds = ds.flat_map(
...     fn='my_schema.py_generate_series',
...     on=['a', 'b', 'c'],
...     as_col=['outCol'])
>>> ds
| a     | b     | c     | outCol |
| ----- | ----- | ----- | ------ |
| int64 | int64 | int64 | int64  |
| ----- | ----- | ----- | ------ |
| 1     | 4     | 1     | 1      |
| 1     | 4     | 1     | 2      |
| 1     | 4     | 1     | 3      |
| 1     | 4     | 1     | 4      |

# Access table columns using the ds.attribute (dot notation) style
>>> ds = ds.flat_map(
...     fn='my_schema.py_generate_series',
...     on=[ds.a, ds.b, ds.c],
...     as_col='udtf_col')
>>> ds
| a     | b     | c     | udtf_col |
| ----- | ----- | ----- | -------- |
| int64 | int64 | int64 | int64    |
| ----- | ----- | ----- | -------- |
| 1     | 4     | 1     | 1        |
| 1     | 4     | 1     | 2        |
| 1     | 4     | 1     | 3        |
| 1     | 4     | 1     | 4        |

map_batches

描述：将给定的函数应用于批量数据。

语法格式：

map_batches(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)

输入参数：

参数	是否必选	参数类型	描述
fn	是	Union[str, Callable]	可调用的函数或其名称，例如myschema.myfunction。
on	是	Union[str, list[str], ]	要应用函数的列或列的集合。
as_col	否	Union[str, list[str], None]	输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。
num_cpus	否	Union[float, None]	CPU的数量。
memory	否	Union[int, None]	内存大小，单位为MB。
arch	否	Union[str, None]	架构类型，参数值为x86或arm。
device	否	Union[str, None]	AI处理单元的类型名，取值为NPU或GPU。
model	否	Union[str, None]	AI处理单元型号，例如910B、A100等。
num_models	否	Union[float, None]	AI处理单元的数量，仅NPU和GPU支持配置。
concurrency	否	Union[int, Tuple[int, int], None]	函数执行时的并发度。
fn_constructor_kwargs	否	-	构造参数，只有当fn为可调用类时，才能提供此项。

返回值类型：

Dataset：调用函数后包含名为as_col的新列的数据集。

groupby

描述：创建一个分组的Dataset。

语法格式：

groupby(*by, **key_exprs)

输入参数：

参数	是否必选	参数类型	描述
by	否	Union[str, Iterable[str], None]	分组表达式。
key_exprs	否	Union[str, Iterable[str]]	命名的分组表达式。

返回值类型：一个分组后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_14", database='my_schema')
>>> ds
| fruit  | price |
| ------ | ----- |
| string | float |
| ------ | ----- |
| apple  | 0.50  |
| apple  | 0.50  |
| banana | 0.25  |
| orange | 0.33  |

join

描述：在两个Dataset之间执行join操作。

语法格式：

join(ds, /, on=(), *, join_type='inner', left_suffix='left_', right_suffix='right_')

输入参数：

参数	是否必选	参数类型	描述
ds	是	Dataset	右侧要连接的数据集。
on	否	Union[str, Sequence[Union[str, BooleanColumn, Literal[True], Literal[False], tuple[str, str]]]]	连接条件，详见示例。
join_type	否	JoinKind	连接方法，如 "inner" 或 "left"。
left_suffix	否	str	用于重命名左侧表中重叠列的格式字符串后缀（例如 "left_"）。
right_suffix	否	str	用于重命名右侧表中重叠列的格式字符串后缀（例如 "right_"）。

返回值类型：join后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds1 = con.load_dataset("demo_table_15", database='my_schema')
>>> ds2 = con.load_dataset("demo_table_16", database='my_schema')

# Equality inner join on the shared id column. Note the _right suffix added to all overlapping columns from the right # table (in this case only the "id" column).
>>> ds1.join(ds2, "id", join_type="inner")
|   id   |  fruit  |  price  |     color     |
| ------ | ------- | ------- | ------------- |
| int64  | string  | float64 | string        |
| ------ | ------- | ------- | ------------- |
|      2 |   apple |    0.25 | Yellow        |
|      3 |  banana |    0.33 | Orange        |

# Explicit equality join using the default join_type value of "inner". Note join_type there is no _right suffix added # to the movieId column since this is an inner join and the movieId column is part of the join condition.
>>> ds1.join(ds2, ds1.id == ds2.id)
|   id   |  fruit  |  price  |     color     |
|--------|---------|---------|---------------|
| int64  | string  | float64 | string        |
|--------|---------|---------|---------------|
|      2 |   apple |    0.25 | Yellow        |
|      3 |  banana |    0.33 | Orange        |

map

描述：对当前Dataset的每一行应用给定函数。

语法格式：

map(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)

输入参数：

参数	是否必选	参数类型	描述
fn	是	Union[str, Callable]	可调用函数或其名称，如myschema.myfunction。
on	是	Union[str, list[str], ]	要应用函数的列或列的集合。
as_col	否	Union[str, list[str], None]	输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。
num_cpus	否	Union[float, None]	CPU的数量。
memory	否	Union[int, None]	内存大小，单位为MB。
arch	否	Union[str, None]	架构类型，取值为x86或arm。
device	否	Union[str, None]	AI处理单元的类型名，取值为NPU或GPU。
model	否	Union[str, None]	AI处理单元型号，例如910B、A100等。
num_models	否	Union[float, None]	AI处理单元的数量，仅NPU和GPU支持配置。
concurrency	否	Union[int, Tuple[int, int], None]	函数执行时的并发度。
fn_constructor_kwargs	否	-	构造参数，只有当fn为可调用类时，才能提供此项。

返回值类型：

Dataset：调用函数后包含新列（列名为as_col）的数据集。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table", database='my_schema')
>>> ds = ds.map(
...     fn='my_schema.multiply_2',
...     on=['col_a'],
...     as_col='col_c'
... )
>>> ds
| col_a | col_b | col_c |
|-------|-------|-------|
| int64 | string | int64 |
|-------|-------|-------|
|     1 | c     | 2     |
|     1 | a     | 2     |
|     2 | a     | 4     |

order_by

描述：根据一个或多个表达式对Dataset进行排序。

语法格式：

order_by(key, descending=False)

输入参数：

参数	是否必选	参数类型	描述
key	否	Union[str, List[str], None]	用于排序的表达式。
descending	否	Union[bool, List[bool]]	是否按降序排序（DESC），默认为False。

返回值类型：排序后的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_15", database='my_schema')
>>> ds
| a     | b      | c     |
|-------|--------|-------|
| 3     | a      | 4     |
| 2     | B      | 6     |
| 1     | c      | 5     |
| 3     | D      | 7     |

# Sort by b. Default is ascending. Note how capital letters come before lowercase
>>> ds.order_by("b")
| a     | b      | c     |
|-------|--------|-------|
| int64 | string | int64 |
|-------|--------|-------|
| 2     | B      | 6     |
| 3     | D      | 7     |
| 3     | a      | 4     |
| 1     | c      | 5     |

# Sort in descending order
>>> ds.order_by(ds.b.desc())
| a     | b      | c     |
|-------|--------|-------|
| int64 | string | int64 |
|-------|--------|-------|
| 1     | c      | 5     |
| 3     | a      | 4     |
| 3     | D      | 7     |
| 2     | B      | 6     |

# Sort by multiple columns/expressions
>>> ds.order_by(["a", ds.c.desc()])
| a     | b      | c     |
|-------|--------|-------|
| int64 | string | int64 |
|-------|--------|-------|
| 1     | c      | 5     |
| 2     | B      | 6     |
| 3     | D      | 7     |
| 3     | a      | 4     |

rename_columns

描述：重命名Dataset中的列。

语法格式：

rename_columns(names, /, **substitutions)

输入参数：

参数	是否必选	参数类型	描述
names	是	Mapping[str, str]	映射（字典），以 {新列名: 旧列名} 的形式指定重命名规则，未在映射中出现的列将保留原名。
substitutions	否	str	显式重命名的列，以关键字参数形式指定，格式为新名=旧名。

返回值类型：重命名后的新Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_8", database='my_schema')
>>> ds
| a     | b      |
|-------|--------|
| int64 | string |
|-------|--------|
| 1     | c      |
| 1     | a      |
| 2     | a      |
>>> ds.rename_columns({"rename_col": "a"})
| rename_col | b      |
|------------|--------|
| int64      | string |
|------------|--------|
| 1          | c      |
| 1          | a      |
| 2          | a      |

schema

描述：返回Dataset的schema。

语法格式：

schema()

输入参数：无。

返回值类型：Schema对象。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_7", database='my_schema')
>>> ds.schema()
ibis.Schema {
  species            string
  island             string
  bill_length_mm     float64
  bill_depth_mm      float64
  flipper_length_mm  int64
}

select_columns

描述：从Dataset的列中选取指定的列。

语法格式：

select_columns(*exprs, **named_exprs)

输入参数：

参数	是否必选	参数类型	描述
exprs	是	Union[Value, str, Iterable[Union[Value, str]]]	列表达式、列名字符串，或由列表达式和列名字符串组成的列表。
named_exprs	否	Union[Value, str]	列表达式（支持命名参数形式）。

返回值类型：包含选定列的Dataset。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_5", database='my_schema')
>>> ds.select_columns("species", "bill_length_mm")
| species    | bill_length_mm |
|------------|----------------|
| string     | float64        |
|------------|----------------|
| Adelie     | 40.0           |
| Adelie     | 41.0           |
| Adelie     | 42.0           |
| Adelie     | 43.0           |

# Selection by zero-indexed column position
>>> ds.select_columns(ds[0], ds[4])
| species    | flipper_length_mm |
|------------|-------------------|
| string     | int64             |
|------------|-------------------|
| Adelie     | 180               |
| Adelie     | 183               |
| Adelie     | 190               |
| Adelie     | 185               |

show

描述：显示查询结果生成的数据。

语法格式：

show(limit=10)

输入参数：

参数	是否必选	参数类型	描述
limit	否	int	限制输出的行数，默认为10。

返回值类型：None。

take

描述：从Dataset中返回最多limit行数据，该方法适用于数据检查和预览。

语法格式：

take(limit)

输入参数：

参数	是否必选	参数类型	描述
limit	是	int	要返回的最大行数。

返回值类型: list[dict[str, Any]] ：包含数据集中最多limit行的列表，每行以字典形式表示。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_9", database='my_schema')
>>> ds.take(3)
[{'a': 1}, {'a': 1}, {'a': 2}]

max

描述：计算Dataset中指定列的最大值。

语法格式：

max(on=None)

输入参数：

参数	是否必选	参数类型	描述
on	否	Union[str, list[str], None]	指定要计算最大值的列。

返回值类型：Dataset

min

描述：计算Dataset中指定列的最小值。

语法格式：

min(on=None)

输入参数：

参数	是否必选	参数类型	描述
on	否	Union[str, list[str], None]	指定要计算最小值的列。

返回值类型：Dataset

mean

描述：计算Dataset中指定列的均值。

语法格式：

mean(on=None)

输入参数：

参数	是否必选	参数类型	描述
on	否	Union[str, list[str], None]	指定要计算均值的列。

返回值类型：Dataset。

unique

描述：计算Dataset中指定列的唯一值集合。

语法格式：

unique(col)

输入参数：

参数	是否必选	参数类型	描述
col	是	str	指定要计算唯一值的列。

返回值类型：list。

limit

描述：从当前Dataset中选择行，起始位置为偏移量。

语法格式：

limit(n, /, *, offset=0)

输入参数：

参数	是否必选	参数类型	描述
n	否	Union[int, None]	要包含的行数。如果为None，则从偏移量开始选择整个数据集。
offset	否	int	起始跳过的行数。

返回值类型：

Dataset ：从偏移量开始的n行数据。

示例：

>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_4", database='my_schema')
>>> ds
| a     | b      |
|-------|--------|
| int64 | string |
|-------|--------|
| 1     | c      |
| 1     | a      |
| 2     | a      |
>>> ds.limit(2)
| a     | b      |
|-------|--------|
| int64 | string |
|-------|--------|
| 1     | c      |
| 1     | a      |
| 2     | a      |
# use None with offset to slice starting from a particular row
>>> ds.limit(None, offset=1)
| a      | b      |
|--------|--------|
| int64  | string |
|--------|--------|
| 1      | a      |
| 2      | a      |

take_batch

描述：从Dataset中返回最多batch_size行数据。

语法格式：

take_batch(batch_size=20, *, batch_format='default')

输入参数：

参数	是否必选	参数类型	描述
batch_size	否	int	batch包含的行数（默认为20）。
batch_format	否	Optional[str]	batch的格式。 "default"返回pyarrow.Table。 "pandas"返回pandas.DataFrame。 "numpy"返回字典形式的numpy数组。

参数

是否必选

参数类型

描述

batch_size

否

int

batch包含的行数（默认为20）。

batch_format

否

Optional[str]

batch的格式。

"default"返回pyarrow.Table。
"pandas"返回pandas.DataFrame。
"numpy"返回字典形式的numpy数组。

返回值类型：按指定格式输出数据集合。

create_async_job

描述：根据作业id恢复作业实例。

语法格式：

create_async_job(statement_id)

输入参数：

参数	是否必选	参数类型	描述
statement_id	是	str	作业唯一标识符。

返回值：AsyncJob对象。

父主题： Aura DataFrame SDK（Python）

上一篇：Session APIs

下一篇：Table APIs

Dataset APIs

columns

add_column

drop_columns

aggregate

count

execute

filter

flat_map

map_batches

groupby

join

map

order_by

rename_columns

schema

select_columns

show

take

max

min

mean

unique

limit

take_batch

create_async_job

相关文档

您对此文档页面的整体评价？