set

Experimental. Essa API é experimental e pode mudar a qualquer momento. Não dependa dele. Ele pode ser ativado de forma experimental definindo --experimental_enable_starlark_set.

O tipo de conjunto mutável integrado. Exemplos de expressões de conjunto:

x = set()           # x is an empty set
y = set([1, 2, 3])  # y is a set with 3 elements
3 in y              # True
0 in y              # False
len(x)              # 0
len(y)              # 3

Um conjunto usado no contexto booleano é verdadeiro somente se não estiver vazio.

s = set()
"non-empty" if s else "empty"  # "empty"
t = set(["x", "y"])
"non-empty" if t else "empty"  # "non-empty"

Os elementos de um conjunto precisam ser hasháveis. x pode ser um elemento de um conjunto se e somente se x puder ser usado como uma chave de um dicionário.

Um conjunto não é hashável. Portanto, não é possível ter um conjunto com outro como elemento.

Não é possível acessar os elementos de um conjunto por índice, mas é possível iterar sobre eles e extrair a lista de elementos de um conjunto na ordem de iteração usando a função integrada list(). Assim como nas listas, é um erro modificar um conjunto enquanto ele está sendo iterado. A ordem de iteração corresponde à ordem de inserção:

s = set([3, 1, 3])
s.add(2)
# prints 3, 1, 2
for item in s:
    print(item)
list(s)  # [3, 1, 2]

Um conjunto s é igual a t se e somente se t for um conjunto que contém os mesmos elementos, possivelmente com uma ordem de iteração diferente. Especificamente, um conjunto é not igual à lista de elementos.

Os conjuntos não são ordenados. As operações <, <=, > e >= não são definidas para conjuntos, e uma lista de conjuntos não pode ser classificada, ao contrário do Python.

A operação | em dois conjuntos retorna a união dos dois conjuntos: um conjunto contendo os elementos encontrados em um ou ambos os conjuntos originais. A operação | tem uma versão de atribuição aumentada. s |= t adiciona ao s todos os elementos de t.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])
s = set([1, 2])
s |= set([2, 3, 4])        # s now equals set([1, 2, 3, 4])

A operação & em dois conjuntos retorna a interseção dos dois conjuntos: um conjunto que contém apenas os elementos encontrados nos dois conjuntos originais. A operação & tem uma versão de atribuição aumentada. s &= t remove de s todos os elementos que não são encontrados em t.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()
s = set([1, 2])
s &= set([0, 1])           # s now equals set([1])

A operação - em dois conjuntos retorna a diferença entre os dois conjuntos: um conjunto que contém os elementos encontrados no conjunto do lado esquerdo, mas não no conjunto do lado direito. A operação - tem uma versão de atribuição aumentada. s -= t remove de s todos os elementos encontrados em t.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 2])
s = set([1, 2])
s -= set([0, 1])           # s now equals set([2])

A operação ^ em dois conjuntos retorna a diferença simétrica dos dois conjuntos: um conjunto que contém os elementos encontrados em exatamente um dos dois conjuntos originais, mas não em ambos. A operação ^ tem uma versão de atribuição aumentada. s ^= t remove de s qualquer elemento de t encontrado em s e adiciona a s qualquer elemento de t que não seja encontrado em s.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])
s = set([1, 2])
s ^= set([0, 1])           # s now equals set([2, 0])

Membros

• adicionar
• clear
• diferença
• difference_update
• descartar
• interseção
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• remover
• symmetric_difference
• symmetric_difference_update
• sindicato
• update

adicionar

None set.add(element)

Parâmetros

limpar

None set.clear()

diferença

set set.difference(*others)

Por exemplo,

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

Parâmetros

difference_update

None set.difference_update(*others)

Por exemplo,

x = set([1, 2, 3, 4])
x.difference_update([2, 3], [3, 4])
# x is now set([1])

Parâmetros

descartar

None set.discard(element)

Parâmetros

intersecção

set set.intersection(*others)

Por exemplo,

set([1, 2, 3]).intersection([1, 2], [2, 3]) == set([2])

Parâmetros

intersection_update

None set.intersection_update(*others)

Por exemplo,

x = set([1, 2, 3, 4])
x.intersection_update([2, 3], [3, 4])
# x is now set([3])

Parâmetros

isdisjoint

bool set.isdisjoint(other)

Por exemplo,

set([1, 2]).isdisjoint([3, 4]) == True
set().isdisjoint(set()) == True
set([1, 2]).isdisjoint([2, 3]) == False

Parâmetros

issubset

bool set.issubset(other)

Por exemplo,

set([1, 2]).issubset([1, 2, 3]) == True
set([1, 2]).issubset([1, 2]) == True
set([1, 2]).issubset([2, 3]) == False

Parâmetros

issuperset

bool set.issuperset(other)

Por exemplo,

set([1, 2, 3]).issuperset([1, 2]) == True
set([1, 2, 3]).issuperset([1, 2, 3]) == True
set([1, 2, 3]).issuperset([2, 3, 4]) == False

Parâmetros

pop

unknown set.pop()

remover

None set.remove(element)

Parâmetros

symmetric_difference

set set.symmetric_difference(other)

Por exemplo,

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

Parâmetros

symmetric_difference_update

None set.symmetric_difference_update(other)

Por exemplo,

set([1, 2, 3]).symmetric_difference([2, 3, 4]) == set([1, 4])

Parâmetros

união

set set.union(*others)

Por exemplo,

set([1, 2]).union([2, 3, 4], [4, 5]) == set([1, 2, 3, 4, 5])

Parâmetros

update

None set.update(*others)

Por exemplo,

x = set([1, 2])
x.update([2, 3], [3, 4])
# x is now set([1, 2, 3, 4])

Parâmetros