所有 Bazel 文件

报告问题 每夜版 · 8.4 · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

所有 Bazel 文件（包括 .bzl 文件、BUILD、MODULE.bazel、VENDOR.bazel 和 WORKSPACE）中提供的方法。

成员

abs

unknown abs(x)

返回数字的绝对值（一个具有相同大小的非负数）。
abs(-2.3) == 2.3

参数

参数 说明
x int；或 float； 必需
一个数字（整数或浮点数）

全部

bool all(elements)

如果所有元素的求值结果均为 True，或者集合为空，则返回 true。使用 bool 函数将元素转换为布尔值。
all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

参数

参数 说明
elements 必需
一个字符串或一个元素集合。

任意

bool any(elements)

如果至少有一个元素的计算结果为 True，则返回 True。使用 bool 函数将元素转换为布尔值。
any([-1, 0, 1]) == True
any([False, 0, ""]) == False

参数

参数 说明
elements 必需
一个字符串或一个元素集合。

bool

bool bool(x=False)

bool 类型的构造函数。如果对象为 None、False、空字符串 ("")、数字 0 或空集合（例如 ()、[]），则返回 False。否则，返回 True。

参数

参数 说明
x 默认值为 False
要转换的变量。

dict

dict dict(pairs=[], **kwargs)

根据可选的位置实参和一组可选的关键字实参创建字典。如果同一键被多次指定，则系统将使用最后一个值。通过关键字实参提供的条目被视为位于通过位置实参提供的条目之后。

参数

参数 说明
pairs 默认值为 []
一个字典，或一个可迭代对象，其每个元素的长度均为 2（键、值）。
kwargs 必需
其他条目的字典。

dir

list dir(x)

返回一个字符串列表：参数对象的属性和方法的名称。

参数

参数 说明
x 必需
要检查的对象。

枚举

list enumerate(list, start=0)

返回一个包含若干对（双元素元组）的列表，其中包含索引 (int) 和输入序列中的项。 
enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]

参数

参数 说明
list 必需的
输入序列。
start int； 默认值为 0
起始索引。

fail

None fail(msg=None, attr=None, sep=" ", *args)

导致执行失败并显示错误。

参数

参数 说明
msg 默认值为 None
已弃用：请改用位置实参。此实参的作用类似于隐式前导位置实参。
attr 字符串；或 None； 默认值为 None
已弃用。导致在错误消息中添加包含此字符串的可选前缀。
sep string； 默认值为 " "
对象之间的分隔符字符串，默认值为空格 (" ")。
args 必需
一个值列表，使用 debugPrint（默认情况下等同于 str）进行格式化，并使用 sep（默认为“ ”）进行联接，这些值会显示在错误消息中。

float

float float(x=unbound)

以浮点值形式返回 x。
  • 如果 x 已经是浮点数，则 float 会原封不动地返回该浮点数。
  • 如果 x 是布尔值，则 float 对于 True 返回 1.0，对于 False 返回 0.0。
  • 如果 x 是 int，则 float 会返回最接近 x 的有限浮点值，如果幅度过大，则返回错误。
  • 如果 x 是字符串，则必须是有效的浮点字面值，或者等于（忽略大小写）NaN、Inf 或 Infinity，并且可以选择性地以 + 或 - 符号开头。
任何其他值都会导致错误。如果不带实参，float() 会返回 0.0。

参数

参数 说明
x 默认值为 unbound
要转换的值。

getattr

unknown getattr(x, name, default=unbound)

返回具有指定名称的结构体字段（如果存在）。如果不是，则返回 default（如果已指定）或引发错误。getattr(x, "foobar") 等效于 x.foobar。
getattr(ctx.attr, "myattr")
getattr(ctx.attr, "myattr", "mydefault")

参数

参数 说明
x 必需
要访问其属性的结构体。
name string; 必需
结构体属性的名称。
default default 为 unbound
如果结构体没有指定名称的属性，则返回的默认值。

hasattr

bool hasattr(x, name)

如果对象 x 具有指定 name 的属性或方法，则返回 True，否则返回 False。示例：
hasattr(ctx.attr, "myattr")

参数

参数 说明
x 必需
要检查的对象。
name string; 必需
属性的名称。

哈希

int hash(value)

返回字符串的哈希值。此值使用与 Java 的 String.hashCode() 相同的算法确定性地计算得出，即：
s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]
 目前不支持对字符串以外的值进行哈希处理。

参数

参数 说明
value string; 必需
要进行哈希处理的字符串值。

int

int int(x, base=unbound)

以 int 值形式返回 x。
  • 如果 x 已经是 int，int 会按原样返回。
  • 如果 x 是布尔值，则 int 会针对 True 返回 1，针对 False 返回 0。
  • 如果 x 是字符串，则必须采用 <sign><prefix><digits> 格式。<sign> 是 "+"、"-" 或空（解释为正）。<digits> 是从 0 到 base - 1 的数字序列，其中字母 a-z（或等效的 A-Z）用作 10-35 的数字。如果 base 为 2/8/16，则 <prefix> 为可选，可以分别为 0b/0o/0x（或等效的 0B/0O/0X）；如果 base 是除这些基数或特殊值 0 之外的任何其他值，则前缀必须为空。如果 base 为 0，则字符串会被解释为整数字面量，也就是说，系统会根据所用的前缀（如果有）选择基数 2/8/10/16 中的一个。如果 base 为 0，则不使用任何前缀，并且位数超过一位，则首位不能为 0；这是为了避免八进制和十进制混淆。字符串表示的数字的大小必须在 int 类型的允许范围内。
  • 如果 x 是浮点数，int 会返回该浮点数的整数值，并向零舍入。如果 x 为非有限值（NaN 或无穷大），则会出错。
如果 x 是任何其他类型，或者相应值是不满足上述格式的字符串，此函数会失败。与 Python 的 int 函数不同，此函数不允许使用零个实参，也不允许字符串实参包含多余的空格。

示例：

int("123") == 123
int("-123") == -123
int("+123") == 123
int("FF", 16) == 255
int("0xFF", 16) == 255
int("10", 0) == 10
int("-0x10", 0) == -16
int("-0x10", 0) == -16
int("123.456") == 123

参数

参数 说明
x 必需
要转换的字符串。
base 默认值为 unbound
用于解释字符串值的基数；默认值为 10。必须介于 2 到 36（含）之间，或为 0 以检测基数，就像 x 是整数字面量一样。如果该值不是字符串，则不得提供此参数。

len

int len(x)

返回字符串、序列（例如列表或元组）、字典、集合或其他可迭代对象的长度。

参数

参数 说明
x 必需
要报告长度的值。

list

list list(x=[])

返回一个新列表，其中包含与指定可迭代值相同的元素。
list([1, 2]) == [1, 2]
list((2, 3, 2)) == [2, 3, 2]
list({5: "a", 2: "b", 4: "c"}) == [5, 2, 4]

参数

参数 说明
x iterable； 默认值为 []
要转换的对象。

max

unknown max(key=None, *args)

返回所有给定实参中的最大值。如果只提供了一个位置实参，则该实参必须是非空的可迭代对象。如果元素不可比较（例如，整数与字符串），或者未提供任何实参，则会引发错误。
max(2, 5, 4) == 5
max([5, 6, 3]) == 6
max("two", "three", "four", key = len) =="three"  # the longest
max([1, -1, -2, 2], key = abs) == -2  # the first encountered with maximal key value

参数

参数 说明
key 可调用对象；或 None；默认值为 None
在比较之前应用于每个元素的可选函数。
args 必需
要检查的元素。

分钟

unknown min(key=None, *args)

返回所有给定实参中的最小值。如果仅提供一个位置实参，则该实参必须是非空的可迭代对象。如果元素不可比较（例如，整数与字符串），或者未提供任何实参，则会引发错误。
min(2, 5, 4) == 2
min([5, 6, 3]) == 3
min("six", "three", "four", key = len) == "six"  # the shortest
min([2, -2, -1, 1], key = abs) == -1  # the first encountered with minimal key value

参数

参数 说明
key 可调用对象；或 None；默认值为 None
在比较之前应用于每个元素的可选函数。
args 必需
要检查的元素。

输出

None print(sep=" ", *args)

以调试输出的形式打印 args。它将以字符串 "DEBUG" 和相应调用的位置（文件和行号）为前缀。将实参转换为字符串的确切方式未指定，并且可能会随时更改。具体而言，它可能与 str() 和 repr() 执行的格式设置不同（且更详细）。

不建议在生产代码中使用 print，因为这会给用户带来垃圾信息。对于弃用，请尽可能使用 fail() 来实现硬性错误。

参数

参数 说明
sep string； 默认值为 " "
对象之间的分隔符字符串，默认值为空格 (" ")。
args 必需
要打印的对象。

范围

sequence range(start_or_stop, stop_or_none=None, step=1)

创建一个列表，其中的项从 start 到 stop，增量为 step。如果仅提供一个实参，则项的范围将从 0 到该元素。
range(4) == [0, 1, 2, 3]
range(3, 9, 2) == [3, 5, 7]
range(3, 0, -1) == [3, 2, 1]

参数

参数 说明
start_or_stop int; 必需
如果提供了 stop，则为 start 元素的值；否则为 stop 的值，实际 start 为 0
stop_or_none int；或 None； 默认值为 None
可选，表示结果列表中不包含的第一项的索引；列表生成会在达到 stop 之前停止。
step int; 默认值为 1
增量（默认值为 1）。可能为负值。

repr

string repr(x)

将任何对象转换为字符串表示形式。这对于调试很有用。
repr("ab") == '"ab"'

参数

参数 说明
x 必需
要转换的对象。

reversed

list reversed(sequence)

返回一个新列表，其中包含原始可迭代序列的元素，但顺序相反。
reversed([3, 5, 4]) == [4, 5, 3]

参数

参数 说明
sequence 可迭代对象； 必需
要反转的可迭代序列（例如列表）。

set

set set(elements=[])

创建一个新 set，其中包含给定可迭代对象的唯一元素，并保留迭代顺序。

如果调用时未提供任何实参，set() 会返回一个新的空集。

例如：

set()                          # an empty set
set([3, 1, 1, 2])              # set([3, 1, 2]), a set of three elements
set({"k1": "v1", "k2": "v2"})  # set(["k1", "k2"]), a set of two elements

参数

参数 说明
elements 默认值为 []
一个集合、一个可哈希值序列或一个字典。

已排序

list sorted(iterable, key=None, *, reverse=False)

返回一个包含所提供可迭代序列的所有元素的新排序列表。如果任何一对元素 x、y 无法使用 x < y 进行比较，则可能会发生错误。除非 reverse 实参为 True，否则元素会按升序排序；如果 reverse 实参为 True，则元素会按降序排序。 排序是稳定的：比较结果相等的元素会保留其原始相对顺序。 
sorted([3, 5, 4]) == [3, 4, 5]
sorted([3, 5, 4], reverse = True) == [5, 4, 3]
sorted(["two", "three", "four"], key = len) == ["two", "four", "three"]  # sort by length

参数

参数 说明
iterable iterable； 必需
要排序的可迭代序列。
key 可调用对象；或 None；默认值为 None
在比较之前应用于每个元素的可选函数。
reverse bool； 默认值为 False
按降序返回结果。

str

string str(x)

将任何对象转换为字符串。这在调试时很有用。
str("ab") == "ab"
str(8) == "8"

参数

参数 说明
x 必需
要转换的对象。

tuple

tuple tuple(x=())

返回一个元组，其中包含与指定可迭代值相同的元素。
tuple([1, 2]) == (1, 2)
tuple((2, 3, 2)) == (2, 3, 2)
tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)

参数

参数 说明
x iterable； 默认值为 ()
要转换的对象。

类型

string type(x)

返回实参的类型名称。这对于调试和类型检查非常有用。示例：
type(2) == "int"
type([1]) == "list"
type(struct(a = 2)) == "struct"
此函数将来可能会发生变化。为了编写与 Python 兼容的代码并确保代码在未来也能正常运行，请仅使用它来比较返回值：
if type(x) == type([]):  # if x is a list

参数

参数 说明
x 必需参数
要检查类型的对象。

zip

list zip(*args)

返回一个 tuple 的 list，其中第 i 个元组包含每个实参序列或可迭代对象的第 i 个元素。列表的大小与最短输入相同。如果只有一个可迭代实参，则返回一个包含 1 元组的列表。如果不带任何实参，则返回一个空列表。示例：
zip()  # == []
zip([1, 2])  # == [(1,), (2,)]
zip([1, 2], [3, 4])  # == [(1, 3), (2, 4)]
zip([1, 2], [3, 4, 5])  # == [(1, 3), (2, 4)]

参数

参数 说明
args 要压缩的必需列表。