---
source_url: https://docs.dolphindb.cn/zh/funcs/a/at.html
fetched_at: 2026-05-19T09:13:20Z
category: funcs
title: at
sha1: 6c43de126dd8337165b1acb172ce61d1a6e17538
---

# at

## 语法

`at(X, [index])`

## 详情

- 只指定一个参数 X：
  - 如果 X 是布尔表达式或向量，函数返回 *X* 中结果为 true 的元素位置。
  - 如果 X 是整型向量，则函数返回一个向量，该向量是根据 X
    中每个位置的数值重复该位置的索引得到，其功能相当于`take(til(count(X)), X)`。例如
    `at(3 0 2)` 结果为
    `[0,0,0,2,2]`。若某个位置的值为非正数，则跳过该位置。
- 指定两个参数：
  - 如果 *index* 是布尔表达式，`at` 函数返回 *X* 中 *index*
    为 true 的位置的元素。 `at` 函数等价于中括号运算符 []。
    比如，`X.at(X>3)` 和 `X[X>3]`
    相同。
  - 如果 *index* 是向量，以向量中的值作为索引值，寻找 *X* 中该索引位置的值并返回。
  - 若 *X* 是函数，*index* 为元组，则 *index*
    中每一个元素均作为 *X* 的参数使用。
  - 如果 *index* 是数据对，如 a:b, 则表示索引范围为 [a,b)，寻找 *X* 中该范围的值并返回。
  - 如果 *index* 是数组向量，对于 *index*
    中的每行元素都作为一个索引值，寻找 *X* 中对应该索引位置的元素，然后返回一个和 *index*
    结构相同的数组向量。

注：

- *index* 作为索引值或索引范围时，若其值不在 [0, size(*X*) - 1] 内，则超出 [0,
  size(*X*) - 1] 的值所对应的位置返回空值。
- 若 *X* 是函数， *index* 为元组，则 index 中每一个元素均作为 X 的参数适用。

## 参数

如果只指定了一个参数，***X*** 可以是布尔表达式/向量，或是整型向量。

如果指定了两个参数：

***X***可以是一个标量、向量（常规向量/元组/数组向量)、矩阵、表、字典、数据对、函数。

***index*** 可以是一个布尔表达式/布尔值、标量、向量（常规向量/元组/数组向量)、数据对。

## 返回值

如果只指定了一个参数，则返回一个向量；如果指定了两个参数，则返回向量、数组向量或矩阵

## 例子

```dolphindb
x = 2 3 -1 0 1
at(x)
// output:[0,0,1,1,1,4]

x=5 7 0 4 2 3
at(x>3)
//output：[0, 1, 3]
// 在位置 0, 1 和 3，x>3 为 true

// 和 x>3 相比
x>3;
//output：[1, 1, 0, 1, 0, 0]

x[x>3]
//output：[5, 7, 4]

x at x>3
//output：[5, 7, 4]

x=5 7 0 0 0 3
at(x==0)
//output：[2, 3, 4]

x[x==0]
//output：[0, 0, 0]

shares=500 1000 1000 600 2000
prices=25.5 97.5  19.2 38.4 101.5
prices[shares>800]
//output：[97.5, 19.2, 101.5]

prices at shares>800
//output: [97.5, 19.2, 101.5]
```

```dolphindb
m=(1..6).reshape(2:3)
m;
```

| 0 | 1 | 2 |
| --- | --- | --- |
| 1 | 3 | 5 |
| 2 | 4 | 6 |

```dolphindb
at(m>3)
//output：[3,4,5]

m[m>3] // 等价于 m at m>3
```

返回：

| col1 | col2 | col3 |
| --- | --- | --- |
|  |  | 5 |
|  | 4 | 6 |

注意区分 *index* 是向量和元组的两种不同场景：

```dolphindb
m at [0,2]  // 选择第 0 列和第 2 列
```

| 0 | 1 |
| --- | --- |
| 1 | 5 |
| 2 | 6 |

```dolphindb
m at (0,2) // 查找特定行列的元素
//output: 5
```

```dolphindb
m at 0:2 // 选择第 0 列和第 1 列
```

返回：

| 0 | 1 |
| --- | --- |
| 1 | 3 |
| 2 | 4 |

*index* 是数组向量的情况：

```dolphindb
a = array(INT[], 0, 10).append!([0 2 3, 0 5, 0 8 8, 9 10])
b =[1, 2, 3]
at(b, a)
//output: [[1,3, ], [1, ], [1, , ], [ , ]]

at(a,a>3)
//output: [,[5],[8,8],[9,10]]
```

下例中，score 是一个简单元组，包含 2 个元素，60 和 70。第二行中，`at` 函数使用
`add` 函数作为 *X*，将 score 中的每个元素作为 `add` 的入参，并将
`at` 的计算结果赋予 result。

```dolphindb
score = (60, 70);
result = at(add,score)
print result

//output: 130
```
