set

O tipo de conjunto integrado. Um conjunto é uma coleção mutável e iterável de valores exclusivos, ou seja, os elementos do conjunto. O nome do tipo de um conjunto é "set".

Os conjuntos fornecem operações de tempo constante para inserir, remover ou verificar a presença de um valor. Os conjuntos são implementados usando uma tabela de hash e, portanto, assim como as chaves de um dicionário, os elementos de um conjunto precisam ser hasháveis. Um valor só pode ser usado como um elemento de um conjunto se puder ser usado como uma chave de um dicionário.

Os conjuntos podem ser construídos usando a função integrada set(), que retorna um novo conjunto contendo os elementos únicos do argumento opcional, que precisa ser iterável. Chamar set() sem um argumento cria um conjunto vazio. Os conjuntos não têm sintaxe literal.

As operações in e not in verificam se um valor está (ou não) em um conjunto:

s = set(["a", "b", "c"])
"a" in s  # True
"z" in s  # False

Um conjunto é iterável e, portanto, pode ser usado como o operando de um loop for, uma compreensão de lista e as várias funções integradas que operam em iteráveis. O comprimento dele pode ser recuperado usando a função integrada len(), e a ordem de iteração é a ordem em que os elementos foram adicionados ao conjunto:

s = set(["z", "y", "z", "y"])
len(s)       # prints 2
s.add("x")
len(s)       # prints 3
for e in s:
    print e  # prints "z", "y", "x"

Um conjunto usado no contexto booleano é verdadeiro se e 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 conjuntos podem ser comparados para igualdade ou desigualdade usando == e !=. Um conjunto s é igual a t se e somente se t for um conjunto que contém os mesmos elementos. A ordem de iteração não é significativa. Em particular, um conjunto não é igual à lista dos elementos dele. Os conjuntos não são ordenados em relação a outros conjuntos, e uma tentativa de comparar dois conjuntos usando <, <=, >, >= ou classificar uma sequência de conjuntos vai falhar.

set() == set()              # True
set() != []                 # True
set([1, 2]) == set([2, 1])  # True
set([1, 2]) != [1, 2]       # True

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.

set([1, 2]) | set([3, 2])  # set([1, 2, 3])

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.

set([1, 2]) & set([2, 3])  # set([2])
set([1, 2]) & set([3, 4])  # set()

A operação - em dois conjuntos retorna a diferença entre os dois conjuntos: um conjunto contendo os elementos encontrados no conjunto do lado esquerdo, mas não no conjunto do lado direito.

set([1, 2]) - set([2, 3])  # set([1])
set([1, 2]) - set([3, 4])  # set([1, 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.

set([1, 2]) ^ set([2, 3])  # set([1, 3])
set([1, 2]) ^ set([3, 4])  # set([1, 2, 3, 4])

Em cada uma das operações acima, os elementos do conjunto resultante mantêm a ordem dos dois conjuntos de operandos, com todos os elementos extraídos do lado esquerdo ordenados antes de qualquer elemento que estivesse presente apenas no lado direito.

As atribuições aumentadas correspondentes, |=, &=, -= e ^=, modificam o conjunto à esquerda.

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

Como todos os valores mutáveis no Starlark, um conjunto pode ser congelado. Depois de congelado, todas as operações subsequentes que tentarem atualizá-lo vão falhar.

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)

É permitido add um valor já presente no conjunto. Isso deixa o conjunto inalterado.

Se você precisar adicionar vários elementos a um conjunto, consulte update ou a operação de atribuição aprimorada |=.

Parâmetros

limpar

None set.clear()

diferença

set set.difference(*others)

Se s e t forem conjuntos, s.difference(t) será equivalente a s - t. No entanto, a operação - exige que ambos os lados sejam conjuntos, enquanto o método difference também aceita sequências e dicionários.

É permitido chamar difference sem argumentos. Isso retorna uma cópia do conjunto.

Por exemplo,

set([1, 2, 3]).difference([2])             # set([1, 3])
set([1, 2, 3]).difference([0, 1], [3, 4])  # set([2])

Parâmetros

difference_update

None set.difference_update(*others)

Se s e t forem conjuntos, s.difference_update(t) será equivalente a s -= t. No entanto, a atribuição aprimorada de -= exige que ambos os lados sejam conjuntos, enquanto o método difference_update também aceita sequências e dicionários.

É permitido chamar difference_update sem argumentos. Isso deixa o conjunto inalterado.

Por exemplo,

s = set([1, 2, 3, 4])
s.difference_update([2])             # None; s is set([1, 3, 4])
s.difference_update([0, 1], [4, 5])  # None; s is set([3])

Parâmetros

descartar

None set.discard(element)

É permitido discard um valor que não está presente no conjunto. Isso deixa o conjunto inalterado. Se você quiser falhar em uma tentativa de remover um elemento ausente, use remove. Se você precisar remover vários elementos de um conjunto, consulte difference_update ou a operação de atribuição ampliada -=.

Por exemplo,

s = set(["x", "y"])
s.discard("y")  # None; s == set(["x"])
s.discard("y")  # None; s == set(["x"])

Parâmetros

intersecção

set set.intersection(*others)

Se s e t forem conjuntos, s.intersection(t) será equivalente a s & t. No entanto, a operação & exige que ambos os lados sejam conjuntos, enquanto o método intersection também aceita sequências e dicionários.

É permitido chamar intersection sem argumentos. Isso retorna uma cópia do conjunto.

Por exemplo,

set([1, 2]).intersection([2, 3])             # set([2])
set([1, 2, 3]).intersection([0, 1], [1, 2])  # set([1])

Parâmetros

intersection_update

None set.intersection_update(*others)

Se s e t forem conjuntos, s.intersection_update(t) será equivalente a s &= t. No entanto, a atribuição aprimorada de &= exige que ambos os lados sejam conjuntos, enquanto o método intersection_update também aceita sequências e dicionários.

É permitido chamar intersection_update sem argumentos. Isso deixa o conjunto inalterado.

Por exemplo,

s = set([1, 2, 3, 4])
s.intersection_update([0, 1, 2])       # None; s is set([1, 2])
s.intersection_update([0, 1], [1, 2])  # None; s is set([1])

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)

Um conjunto é sempre considerado um subconjunto de si mesmo.

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)

Um conjunto é sempre considerado um superconjunto de si mesmo.

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

Falha se o conjunto estiver vazio.

Por exemplo,

s = set([3, 1, 2])
s.pop()  # 3; s == set([1, 2])
s.pop()  # 1; s == set([2])
s.pop()  # 2; s == set()
s.pop()  # error: empty set

remover

None set.remove(element)

remove falha se o elemento não estiver presente no conjunto. Se você não quiser falhar em uma tentativa de remover um elemento ausente, use discard. Se você precisar remover vários elementos de um conjunto, consulte difference_update ou a operação de atribuição ampliada -=.

Parâmetros

symmetric_difference

set set.symmetric_difference(other)

Se s e t forem conjuntos, s.symmetric_difference(t) será equivalente a s ^ t. No entanto, observe que a operação ^ exige que ambos os lados sejam conjuntos, enquanto o método symmetric_difference também aceita uma sequência ou um dicionário.

Por exemplo,

set([1, 2]).symmetric_difference([2, 3])  # set([1, 3])

Parâmetros

symmetric_difference_update

None set.symmetric_difference_update(other)

Se s e t forem conjuntos, s.symmetric_difference_update(t) será equivalente a "s ^= t; however, note that the ^=`". A atribuição aprimorada exige que ambos os lados sejam conjuntos, enquanto o método symmetric_difference_update também aceita uma sequência ou um dicionário.

Por exemplo,

s = set([1, 2])
s.symmetric_difference_update([2, 3])  # None; s == set([1, 3])

Parâmetros

união

set set.union(*others)

Se s e t forem conjuntos, s.union(t) será equivalente a s | t. No entanto, a operação | exige que ambos os lados sejam conjuntos, enquanto o método union também aceita sequências e dicionários.

É permitido chamar union sem argumentos. Isso retorna uma cópia do conjunto.

Por exemplo,

set([1, 2]).union([2, 3])                    # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"})  # set([1, 2, 3, 4])

Parâmetros

update

None set.update(*others)

Por exemplo,

s = set()
s.update([1, 2])          # None; s is set([1, 2])
s.update([2, 3], [3, 4])  # None; s is set([1, 2, 3, 4])

Se s e t forem conjuntos, s.update(t) será equivalente a s |= t. No entanto, a atribuição aumentada de |= exige que ambos os lados sejam conjuntos, enquanto o método update também aceita sequências e dicionários.

É permitido chamar update sem argumentos. Isso deixa o conjunto inalterado.

Parâmetros