Todos os arquivos do Bazel

Métodos disponíveis em todos os arquivos do Bazel, incluindo arquivos .bzl, BUILD, MODULE.bazel, VENDOR.bazel e WORKSPACE.

Membros

• abs
• todos
• qualquer um
• bool
• dict
• dir
• enumerate
• fail
• float
• getattr
• hasattr
• hash
• int
• len
• list
• max
• min
• print
• Intervalo
• repr
• revertida
• set
• sorted
• str
• tuple
• type
• zip

abs

unknown abs(x)

Retorna o valor absoluto de um número (um número não negativo com a mesma magnitude).

abs(-2.3) == 2.3

Parâmetros

Parâmetro	Descrição
x	int ou float; required Um número (int ou float)

todas

bool all(elements)

Retorna "true" se todos os elementos forem avaliados como "True" ou se a coleção estiver vazia. Os elementos são convertidos em booleano usando a função bool.

all(["hello", 3, True]) == True
all([-1, 0, 1]) == False

Parâmetros

Parâmetro	Descrição
elements	obrigatório Uma string ou uma coleção de elementos.

qualquer

bool any(elements)

Retorna "true" se pelo menos um elemento for avaliado como "True". Os elementos são convertidos em booleano usando a função bool.

any([-1, 0, 1]) == True
any([False, 0, ""]) == False

Parâmetros

Parâmetro	Descrição
elements	obrigatório Uma string ou uma coleção de elementos.

bool

bool bool(x=False)

Construtor para o tipo booleano. Ele retorna False se o objeto for None, False, uma string vazia (""), o número 0 ou uma coleção vazia (por exemplo, (), []). Caso contrário, ele retorna True.

Parâmetros

Parâmetro	Descrição
x	O padrão é False A variável a ser convertida.

dict

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

Cria um dicionário de um argumento posicional opcional e um conjunto opcional de argumentos de palavra-chave. Se a mesma chave for fornecida várias vezes, o último valor será usado. As entradas fornecidas por argumentos de palavra-chave são consideradas posteriores às entradas fornecidas pelo argumento posicional.

Parâmetros

Parâmetro	Descrição
pairs	O padrão é [] Um dict ou um iterável cujos elementos têm comprimento 2 (chave, valor).
kwargs	required Dicionário de entradas adicionais.

dir

list dir(x)

Retorna uma lista de strings: os nomes dos atributos e métodos do objeto de parâmetro.

Parâmetros

Parâmetro	Descrição
x	obrigatório O objeto a ser verificado.

enumerar

list enumerate(list, start=0)

Retorna uma lista de pares (tuplas de dois elementos) com o índice (int) e o item da sequência de entrada.

enumerate([24, 21, 84]) == [(0, 24), (1, 21), (2, 84)]

Parâmetros

Parâmetro	Descrição
list	sequência de entrada obrigatória.
start	int; o padrão é 0 índice inicial.

fail

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

Faz com que a execução falhe com um erro.

Parâmetros

Parâmetro	Descrição
msg	O padrão é None Descontinuado: use argumentos posicionais. Esse argumento funciona como um argumento posicional inicial implícito.
attr	string ou None. O padrão é None . Obsoleto. Faz com que um prefixo opcional contendo essa string seja adicionado à mensagem de erro.
sep	string; o padrão é " " A string separadora entre os objetos. O padrão é espaço (" ").
args	required Uma lista de valores, formatada com debugPrint (que é equivalente a str por padrão) e unida com sep (o padrão é " "), que aparece na mensagem de erro.

float

float float(x=unbound)

Retorna x como um valor de ponto flutuante.

• Se x já for um ponto flutuante, float o retornará sem alterações.
• Se x for um booleano, float vai retornar 1,0 para "True" e 0,0 para "False".
• Se x for um número inteiro, float vai retornar o valor de ponto flutuante finito mais próximo de x ou um erro se a magnitude for muito grande.
• Se x for uma string, ela precisará ser um literal de ponto flutuante válido ou ser igual (ignorando maiúsculas e minúsculas) a NaN, Inf ou Infinity, precedida opcionalmente por um sinal + ou -.

Qualquer outro valor causa um erro. Sem argumento, float() retorna 0,0.

Parâmetros

Parâmetro	Descrição
x	O padrão é unbound O valor a ser convertido.

getattr

unknown getattr(x, name, default=unbound)

Retorna o campo da struct com o nome especificado, se ele existir. Caso contrário, ele retorna default (se especificado) ou gera um erro. getattr(x, "foobar") é equivalente a x.foobar.

getattr(ctx.attr, "myattr")
getattr(ctx.attr, "myattr", "mydefault")

Parâmetros

Parâmetro	Descrição
x	required A struct cujo atributo é acessado.
name	string; required O nome do atributo struct.
default	O padrão é unbound O valor padrão a ser retornado caso a struct não tenha um atributo com o nome especificado.

hasattr

bool hasattr(x, name)

Retorna True se o objeto x tiver um atributo ou método do name especificado. Caso contrário, retorna False. Exemplo:

hasattr(ctx.attr, "myattr")

Parâmetros

Parâmetro	Descrição
x	obrigatório O objeto a ser verificado.
name	string; required O nome do atributo.

jogo da velha

int hash(value)

Retorna um valor de hash para uma string. Isso é calculado de forma determinística usando o mesmo algoritmo de String.hashCode() do Java, ou seja: No momento, não há suporte para hash de valores que não sejam strings.

s[0] * (31^(n-1)) + s[1] * (31^(n-2)) + ... + s[n-1]

Parâmetros

Parâmetro	Descrição
value	string; required Valor de string para hash.

int

int int(x, base=unbound)

Retorna x como um valor inteiro.

• Se x já for um int, int o retornará sem alterações.
• Se x for um booleano, int vai retornar 1 para "True" e 0 para "False".
• Se x for uma string, ela precisará ter o formato <sign><prefix><digits>. <sign> é "+", "-" ou vazio (interpretado como positivo). <digits> é uma sequência de dígitos de 0 a base - 1, em que as letras a-z (ou A-Z) são usadas como dígitos de 10 a 35. No caso em que base é 2/8/16, <prefix> é opcional e pode ser 0b/0o/0x (ou, de forma equivalente, 0B/0O/0X), respectivamente. Se base for qualquer outro valor além dessas bases ou do valor especial 0, o prefixo precisará estar vazio. Quando base é 0, a string é interpretada como um literal inteiro, no sentido de que uma das bases 2/8/10/16 é escolhida dependendo de qual prefixo, se houver, é usado. Se base for 0, nenhum prefixo será usado. Se houver mais de um dígito, o primeiro não poderá ser 0 para evitar confusão entre octal e decimal. A magnitude do número representado pela string precisa estar dentro do intervalo permitido para o tipo int.
• Se x for um ponto flutuante, int vai retornar o valor inteiro do ponto flutuante, arredondando para zero. É um erro se x for não finito (NaN ou infinito).

Essa função falha se x for qualquer outro tipo ou se o valor for uma string que não satisfaz o formato acima. Ao contrário da função int do Python, essa função não permite argumentos zero nem espaços em branco desnecessários para argumentos de string.

Exemplos:

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

Parâmetros

Parâmetro	Descrição
x	obrigatório A string a ser convertida.
base	O padrão é unbound A base usada para interpretar um valor de string. O padrão é 10. Precisa estar entre 2 e 36 (inclusive) ou ser 0 para detectar a base como se x fosse um literal inteiro. Esse parâmetro não pode ser fornecido se o valor não for uma string.

len

int len(x)

Retorna o comprimento de uma string, sequência (como uma lista ou tupla), dict, conjunto ou outro iterável.

Parâmetros

Parâmetro	Descrição
x	obrigatório O valor cujo comprimento será informado.

list

list list(x=[])

Retorna uma nova lista com os mesmos elementos do valor iterável especificado.

list([1, 2]) == [1, 2]
list((2, 3, 2)) == [2, 3, 2]
list({5: "a", 2: "b", 4: "c"}) == [5, 2, 4]

Parâmetros

Parâmetro	Descrição
x	iterable; o padrão é [] O objeto a ser convertido.

máx.

unknown max(key=None, *args)

Retorna o maior de todos os argumentos fornecidos. Se apenas um argumento posicional for fornecido, ele precisará ser um iterável não vazio.Será um erro se os elementos não forem comparáveis (por exemplo, int com string) ou se nenhum argumento for fornecido.

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

Parâmetros

Parâmetro	Descrição
key	chamável ou None; o padrão é None . Uma função opcional aplicada a cada elemento antes da comparação.
args	required Os elementos a serem verificados.

min

unknown min(key=None, *args)

Retorna o menor de todos os argumentos fornecidos. Se apenas um argumento posicional for fornecido, ele precisará ser um iterável não vazio. Será um erro se os elementos não forem comparáveis (por exemplo, int com string) ou se nenhum argumento for fornecido.

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

Parâmetros

Parâmetro	Descrição
key	chamável ou None; o padrão é None . Uma função opcional aplicada a cada elemento antes da comparação.
args	required Os elementos a serem verificados.

mostrar

None print(sep=" ", *args)

Imprime args como saída de depuração. Ele terá como prefixo a string "DEBUG" e o local (arquivo e número da linha) dessa chamada. A maneira exata como os argumentos são convertidos em strings não é especificada e pode mudar a qualquer momento. Em particular, ele pode ser diferente (e mais detalhado) da formatação feita por str() e repr().

Não é recomendável usar print em código de produção devido ao spam que ele cria para os usuários. Para descontinuações, prefira um erro fatal usando fail() sempre que possível.

Parâmetros

Parâmetro	Descrição
sep	string; o padrão é " " A string separadora entre os objetos. O padrão é espaço (" ").
args	required Os objetos a serem impressos.

período

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

Cria uma lista em que os itens vão de start a stop, usando um incremento de step. Se um único argumento for fornecido, os itens vão variar de 0 até esse elemento.

range(4) == [0, 1, 2, 3]
range(3, 9, 2) == [3, 5, 7]
range(3, 0, -1) == [3, 2, 1]

Parâmetros

Parâmetro	Descrição
start_or_stop	int; required Valor do elemento de início se a parada for fornecida. Caso contrário, valor da parada e o início real é 0.
stop_or_none	int ou None; o padrão é None . Índice opcional do primeiro item não a ser incluído na lista resultante. A geração da lista é interrompida antes de stop ser alcançado.
step	int; o padrão é 1 O incremento (o padrão é 1). Ele pode ser negativo.

repr

string repr(x)

Converte qualquer objeto em uma representação de string. Isso é útil para depuração.

repr("ab") == '"ab"'

Parâmetros

Parâmetro	Descrição
x	obrigatório O objeto a ser convertido.

anulou

list reversed(sequence)

Retorna uma nova lista não congelada que contém os elementos da sequência iterável original em ordem inversa.

reversed([3, 5, 4]) == [4, 5, 3]

Parâmetros

Parâmetro	Descrição
sequence	iterable; required A sequência iterável (por exemplo, lista) a ser invertida.

set

set set(elements=[])

Cria um novo conjunto que contém os elementos únicos de um determinado iterável, preservando a ordem de iteração.

Se for chamado sem um argumento, set() vai retornar um novo conjunto vazio.

Por exemplo,

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

Parâmetros

Parâmetro	Descrição
elements	O padrão é [] Um conjunto, uma sequência de valores hasháveis ou um dicionário.

ordenada

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

Retorna uma nova lista classificada que contém todos os elementos da sequência iterável fornecida. Um erro pode ocorrer se um par de elementos x, y não puder ser comparado usando x < y. Os elementos são classificados em ordem crescente, a menos que o argumento "reverse" seja "True", nesse caso, a ordem é decrescente. A classificação é estável: elementos que são iguais mantêm a ordem relativa original.

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

Parâmetros

Parâmetro	Descrição
iterable	iterable; required A sequência iterável a ser classificada.
key	chamável ou None; o padrão é None . Uma função opcional aplicada a cada elemento antes da comparação.
reverse	bool; o padrão é False Retorna resultados em ordem decrescente.

str

string str(x)

Converte qualquer objeto em string. Isso é útil para depuração.

str("ab") == "ab"
str(8) == "8"

Parâmetros

Parâmetro	Descrição
x	obrigatório O objeto a ser convertido.

tuple

tuple tuple(x=())

Retorna uma tupla com os mesmos elementos do valor iterável especificado.

tuple([1, 2]) == (1, 2)
tuple((2, 3, 2)) == (2, 3, 2)
tuple({5: "a", 2: "b", 4: "c"}) == (5, 2, 4)

Parâmetros

Parâmetro	Descrição
x	iterable; o padrão é () O objeto a ser convertido.

tipo

string type(x)

Retorna o nome do tipo do argumento. Isso é útil para depuração e verificação de tipos. Exemplos:

type(2) == "int"
type([1]) == "list"
type(struct(a = 2)) == "struct"

Essa função pode mudar no futuro. Para escrever um código compatível com Python e evitar problemas futuros, use-o apenas para comparar valores de retorno:

if type(x) == type([]):  # if x is a list

Parâmetros

Parâmetro	Descrição
x	required O objeto a ser verificado.

zip

list zip(*args)

Retorna um list de tuples, em que a tupla i-ésima contém o elemento i-ésimo de cada uma das sequências ou iteráveis de argumentos. A lista tem o tamanho da entrada mais curta. Com um único argumento iterável, ele retorna uma lista de tuplas de 1 elemento. Sem argumentos, ele retorna uma lista vazia. Exemplos:

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)]

Parâmetros

Parâmetro	Descrição
args	obrigatório listas para compactar.