set

Informar um problema Ver a fonte Nightly · 8.0 · 7.5 · 7.4 · 7.3 · 7.2

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

None set.add(element)

Adiciona um elemento ao conjunto.

É 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

Parâmetro Descrição
element elemento obrigatório
Elemento a ser adicionado.

limpar

None set.clear()

Remove todos os elementos do conjunto.

diferença

set set.difference(*others)

Retorna um novo conjunto mutável contendo a diferença entre esse conjunto e outros.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.

difference_update

None set.difference_update(*others)

Remove todos os elementos encontrados em outros elementos deste conjunto.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.

descartar

None set.discard(element)

Remove um elemento do conjunto, se ele estiver presente.

É 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

Parâmetro Descrição
element required
Elemento a ser descartado. Precisa ser hashável.

intersecção

set set.intersection(*others)

Retorna um novo conjunto mutável que contém a interseção desse conjunto com outros.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.

intersection_update

None set.intersection_update(*others)

Remove todos os elementos que não são encontrados em todos os outros elementos do conjunto.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.

isdisjoint

bool set.isdisjoint(other)

Retorna verdadeiro se esse conjunto não tiver elementos em comum com outro.

Por exemplo, 

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

Parâmetros

Parâmetro Descrição
other required
Um conjunto, uma sequência de elementos hasháveis ou um dicionário.

issubset

bool set.issubset(other)

Retorna verdadeiro se este conjunto for um subconjunto de outro.

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

Parâmetro Descrição
other required
Um conjunto, uma sequência de elementos hasháveis ou um dicionário.

issuperset

bool set.issuperset(other)

Retorna verdadeiro se esse conjunto for um superconjunto de outro.

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

Parâmetro Descrição
other required
Um conjunto, uma sequência de elementos hasháveis ou um dicionário.

pop

unknown set.pop()

Remove e retorna o primeiro elemento do conjunto (na ordem de iteração, que é a ordem em que os elementos foram adicionados ao conjunto).

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 um elemento, que precisa estar presente no conjunto, dele.

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

Parâmetro Descrição
element required
Elemento a ser removido. Precisa ser um elemento do conjunto (e hashável).

symmetric_difference

set set.symmetric_difference(other)

Retorna um novo conjunto mutável contendo a diferença simétrica desse conjunto com outro conjunto, sequência ou dicionário.

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

Parâmetro Descrição
other required
Um conjunto, uma sequência de elementos hasháveis ou um dicionário.

symmetric_difference_update

None set.symmetric_difference_update(other)

Retorna um novo conjunto mutável contendo a diferença simétrica desse conjunto com outro conjunto, sequência ou dicionário.

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

Parâmetro Descrição
other required
Um conjunto, uma sequência de elementos hasháveis ou um dicionário.

união

set set.union(*others)

Retorna um novo conjunto mutável que contém a união desse conjunto com outros.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.

update

None set.update(*others)

Adiciona os elementos encontrados em outros conjuntos a este conjunto.

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

Parâmetro Descrição
others required
Conj., sequências de elementos hasháveis ou dicionários.