2.10. Conjuntos#

Um conjunto (set) é uma coleção não ordenada de itens únicos. Adicionar um valor que já está presente não tem efeito; a iteração produz cada valor exatamente uma vez. Os conjuntos são a ferramenta certa quando pertinência e deduplicação importam, e a ordenação não.

2.10.1. Criando um conjunto#

Use chaves para um conjunto não vazio, ou set() para um vazio:

colours = {"red", "green", "blue"}
empty = set()

As chaves se parecem com um literal de dict; {} por si só é um dict vazio, não um conjunto vazio – um dos acidentes históricos do Python. Use set() para o caso vazio.

set() também constrói um conjunto a partir de qualquer iterável, que é a maneira padrão de eliminar duplicatas de uma sequência:

nums = [1, 2, 2, 3, 1, 4]
unique = set(nums)
print(unique)

Saída:

{1, 2, 3, 4}

A ordem de impressão pode variar – conjuntos não prometem iterar em nenhuma ordem específica.

2.10.2. Set vs dict#

Tanto conjuntos quanto dicts armazenam itens únicos em uma tabela hash. O que cada item carrega consigo é a diferença:

  • Um dict armazena pares chave-valor. Consultar uma chave retorna seu valor.

  • Um set armazena apenas os itens. Consultar um item informa se ele está lá.

A escolha entre os dois é sobre se o valor ao lado de cada item significa algo:

  • Recorra a um set quando nenhum valor pertence ao lado de cada item – você só se importa se o item está presente, ou está combinando grupos de itens únicos com união / interseção.

  • Recorra a um dict quando cada item está emparelhado com dados que a consulta deve recuperar – um mapa de configuração, um cache, um contador indexado por nome.

Os dois tipos compartilham muita sintaxe superficial, que é de onde vem a maior parte da confusão. As diferenças em um único bloco:

set

dict

contém

itens únicos

chaves únicas, cada uma com um valor

literal preenchido

{1, 2, 3}

{"a": 1, "b": 2}

literal vazio

set()

{}

teste de pertinência

x in s

k in d (apenas chaves)

buscar um valor

n/d

d[k]

adicionar um item

s.add(x)

d[k] = v

iterar

produz itens

produz chaves (use d.items() para pares)

A assimetria entre os literais preenchido e vazio é a pegadinha que vale a pena destacar:

  • Chaves com itens dentro – {1, 2, 3} – são um literal de conjunto; chaves com pares chave-valor – {"a": 1} – são um literal de dict. O parser os distingue pelo que há dentro.

  • Chaves com nada dentro – {} – são um dict vazio, não um conjunto vazio. Os dicts vieram primeiro; o literal vazio pertence a eles. Um conjunto vazio não tem literal com chaves e deve ser escrito como set().

Um padrão comum quando apenas as chaves de um dict são lidas é trocar por um conjunto – isso torna a intenção óbvia e elimina os valores não utilizados da memória.

2.10.3. Adicionando e removendo#

s = {1, 2, 3}
s.add(4)
s.discard(99)            # silent: 99 not in s
s.remove(2)
print(s)

Saída:

{1, 3, 4}

2.10.4. Pertinência#

O operador in testa a pertinência. Em um conjunto, ele é aproximadamente de tempo constante independentemente do tamanho – o que é a principal razão para escolher um conjunto em vez de uma list quando você só precisa perguntar “este valor está aí”:

if "red" in colours:
    print("colour is allowed")

Uma list com o mesmo conteúdo varreria a partir do início a cada vez, o que é aceitável para dez itens mas lento para dez mil.

2.10.5. Operações de conjunto#

Dois conjuntos podem ser combinados com as operações matemáticas usuais. Cada uma tem tanto uma forma de operador quanto uma forma de método:

  • a | b ou a.union(b) – tudo em qualquer um dos conjuntos.

  • a & b ou a.intersection(b) – apenas o que aparece em ambos.

  • a - b ou a.difference(b) – o que está em a mas não em b.

  • a ^ b ou a.symmetric_difference(b) – o que está em um mas não em ambos.

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)

Saída:

{1, 2, 3, 4, 5, 6}
{3, 4}
{1, 2}
{1, 2, 5, 6}

As formas de operador são somente leitura; as formas de método aceitam qualquer iterável à direita, não apenas outro conjunto (a.union([5, 6])). Escolha a que ler melhor no contexto.

2.10.6. O que pode entrar em um conjunto#

Os elementos de um conjunto devem ser hashable – a mesma restrição das chaves de dict. int, float, str, bool, bytes e tuple (quando seu conteúdo é, por sua vez, hashable) todos funcionam. list e dict não; tentar adicionar um deles gera TypeError.

2.10.7. frozenset#

Um set comum é mutável: toda chamada a add / remove / discard altera o objeto no próprio local. Essa mutabilidade o desqualifica de ser hashable, então um conjunto não pode ser usado como chave de dict nem como membro de outro conjunto.

frozenset é o equivalente imutável. Ele tem as mesmas consultas e operadores (in, |, &, -, ^) que set, mas não tem add / remove nem métodos que mutam. Como nada pode jamais alterar seu conteúdo, o hash de um frozenset é bem definido – então ele é hashable:

primary = frozenset({"red", "green", "blue"})
secondary = frozenset({"yellow", "purple", "orange"})

palettes = {
    primary: "RGB",
    secondary: "mixed",
}

print(palettes[primary])

Saída:

RGB

Construa um frozenset a partir de qualquer iterável – frozenset() para o caso vazio, frozenset(some_set) para tirar um snapshot imutável de um conjunto existente:

snapshot = frozenset(s)         # immutable copy of s
s.add("new")                    # snapshot does not change

Duas razões comuns para recorrer a ele:

  • Uso como chave de dict ou membro de conjunto. Em qualquer lugar em que um único valor não consegue capturar o que você precisa, um frozenset de valores consegue – “o conjunto de características suportadas por este driver”, “o conjunto de pinos que este perfil usa”.

  • Travar uma constante. Um frozenset de nomes permitidos em nível de módulo não pode ser mutado acidentalmente por um chamador; um set comum pode. Prefira frozenset para qualquer coisa que deva ser somente leitura após a construção.