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 oferecem operações de tempo constante para inserir, remover ou verificar a presença de um valor. Os conjuntos são implementados usando uma tabela hash e, portanto, assim como as chaves de um dicionário, os elementos de um conjunto precisam ser hasháveis. Um valor pode ser usado como um elemento de um conjunto se e somente se ele puder ser usado como uma chave de um dicionário.

Os conjuntos podem ser criados usando a função integrada set(), que retorna um novo conjunto contendo os elementos exclusivos do argumento opcional, que precisa ser um 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 está) 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 em 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"

É possível comparar conjuntos 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 é importante. 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 de 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 deles: um conjunto que contém os elementos encontrados em um ou nos dois conjuntos originais.

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

A operação & em dois conjuntos retorna a interseção deles: 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 eles: um conjunto que contém os elementos encontrados no conjunto do lado esquerdo, mas não no 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 deles: 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 estava presente apenas no lado direito.

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

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 em Starlark, um conjunto pode ser congelado. Depois disso, todas as operações subsequentes que tentarem atualizá-lo vão falhar.

Membros

• adicionar
• clear
• diferença
• difference_update
• discard
• intersection
• intersection_update
• isdisjoint
• issubset
• issuperset
• pop
• remover
• symmetric_difference
• symmetric_difference_update
• união
• update

adicionar

None set.add(element)

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

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

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, observe que 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, observe que a atribuição aumentada -= exige que os dois lados sejam conjuntos, enquanto o método difference_update também aceita sequências e dicionários.

É permitido chamar difference_update sem argumentos, o que 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, o que deixa o conjunto inalterado. Se quiser falhar em uma tentativa de remover um elemento não presente, use remove. Se você precisar remover vários elementos de um conjunto, consulte difference_update ou a operação de atribuição aumentada -=.

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, observe que 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 aumentada &= exige que os dois lados sejam conjuntos, enquanto o método intersection_update também aceita sequências e dicionários.

É permitido chamar intersection_update sem argumentos, o que 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 não presente, use discard. Se você precisar remover vários elementos de um conjunto, consulte difference_update ou a operação de atribuição aumentada -=.

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 aumentada exige que os dois 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, observe que 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 |= exige que os dois 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