Sets em Python

Um set em Python é uma coleção não ordenada de elementos únicos e hasheáveis. Como os sets impõem a unicidade automaticamente e suportam testes de pertencimento rápidos, são ideais para deduplicação, álgebra de conjuntos matemáticos e verificação de sobreposição entre coleções.

Este capítulo aborda:

• Como criar sets (sintaxe literal e set())
• Adicionar e remover elementos — e quando cada método gera um erro
• As quatro operações de set: união, interseção, diferença, diferença simétrica
• Atalhos com operadores (|, &, -, ^)
• Testes de subconjunto e superconjunto
• Compreensões de set
• Sets congelados (frozenset) para sets imutáveis e hasheáveis

Criando Sets

Usando chaves

A forma mais rápida de criar um set não vazio é com uma literal de chaves. Cada valor aparece apenas uma vez, independentemente de quantas vezes for escrito.

Definir um set em Python

Usando o construtor set()

Passe qualquer iterável — uma lista, tupla, string ou range — para set() para construir um set a partir dele. Valores duplicados são silenciosamente descartados.

Converter uma lista em um set em Python

Importante: set vazio

Para criar um set vazio, você deve usar set(). Escrever {} cria um dicionário vazio, não um set.

empty_set  = set()          # correct
empty_dict = {}             # this is a dict!

print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

O que pode estar dentro de um set?

Um elemento de set deve ser hasheável — tipos imutáveis como int, float, str, bool e tuple funcionam bem. Listas e outros sets não podem ser elementos porque são mutáveis e, portanto, não são hasheáveis.

valid   = {1, "hello", (2, 3), True}  # OK
# invalid = {[1, 2]}                  # TypeError: unhashable type: 'list'
print(valid)

Acessando Elementos de um Set

Sets são não ordenados, portanto os elementos não possuem índice e não é possível recuperar um único item por posição. A forma padrão de visitar cada elemento é com um loop for.

colors = {"red", "green", "blue"}
for color in colors:
    print(color)
# Output order may vary — sets are unordered

Para verificar se um valor específico existe, use o operador in:

colors = {"red", "green", "blue"}
print("red" in colors)    # True
print("yellow" in colors) # False

O teste de pertencimento em um set é O(1) em média — muito mais rápido do que pesquisar em uma lista quando as coleções são grandes.

Para um capítulo dedicado, veja Acessar Itens de Set.

Adicionando Elementos

Use add() para inserir um único elemento, ou update() para adicionar múltiplos elementos de qualquer iterável.

Adicionar um elemento a um set em Python

update() aceita qualquer iterável e adiciona todos os seus elementos:

my_set = {1, 2, 3}
my_set.update([4, 5], {6, 7})
print(my_set)   # {1, 2, 3, 4, 5, 6, 7}

Veja Adicionar Itens ao Set para mais detalhes.

Removendo Elementos

Python oferece vários métodos para remover elementos, cada um com comportamento diferente quando o elemento está ausente.

Remover um elemento de um set em Python

Quando escolher remove vs discard: use remove() quando o elemento deve estar presente e sua ausência indica um erro. Use discard() quando o elemento pode ou não estar lá e você simplesmente quer removê-lo.

Veja Remover Itens de Set para todos os métodos de remoção.

Operações de Set

Os sets em Python implementam as quatro operações clássicas de álgebra de conjuntos. Cada operação está disponível tanto como método quanto como operador — escolha o que for mais claro no contexto.

Operações de set em Python

set1 = {1, 2, 3}
set2 = {2, 3, 4}

# Union — all elements from both sets
print(set1.union(set2))              # {1, 2, 3, 4}
print(set1 | set2)                   # {1, 2, 3, 4}

# Intersection — only elements present in both
print(set1.intersection(set2))       # {2, 3}
print(set1 & set2)                   # {2, 3}

# Difference — elements in set1 but not set2
print(set1.difference(set2))         # {1}
print(set1 - set2)                   # {1}

# Symmetric difference — elements in either set, but not both
print(set1.symmetric_difference(set2))  # {1, 4}
print(set1 ^ set2)                      # {1, 4}

Testes de subconjunto e superconjunto

Use issubset(), issuperset(), ou os operadores de comparação <= / >= para testar relações de contenção.

a = {1, 2}
b = {1, 2, 3, 4}

print(a.issubset(b))    # True  — every element of a is in b
print(a <= b)           # True

print(b.issuperset(a))  # True  — b contains all elements of a
print(b >= a)           # True

print(a < b)            # True  — proper subset (a != b)
print(a == b)           # False

isdisjoint() retorna True quando dois sets não compartilham nenhum elemento:

x = {1, 2, 3}
y = {4, 5, 6}
print(x.isdisjoint(y))  # True

Veja Unir Sets para variantes de atualização in-place como |=, &=, -= e ^=.

Compreensões de Set

Assim como as compreensões de lista, você pode construir um set com uma expressão compacta usando chaves e uma cláusula for.

squares = {x ** 2 for x in range(1, 6)}
print(squares)  # {1, 4, 9, 16, 25}

# With a filter condition
even_squares = {x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # {4, 16, 36, 64, 100}

Como o resultado é um set, valores duplicados são automaticamente eliminados:

words = ["apple", "banana", "avocado", "blueberry"]
first_letters = {w[0] for w in words}
print(first_letters)  # {'a', 'b'}

Sets Congelados

Um frozenset é uma versão imutável de um set. Uma vez criado, elementos não podem ser adicionados ou removidos. Sets congelados são hasheáveis, o que significa que podem ser usados como chaves de dicionário ou como elementos de outro set.

fs = frozenset([1, 2, 3])
print(fs)               # frozenset({1, 2, 3})

# All read-only operations work
print(2 in fs)          # True
print(fs | {4, 5})      # frozenset({1, 2, 3, 4, 5})

# fs.add(4)             # AttributeError — frozenset has no add()

# Use as a dictionary key
permissions = {
    frozenset(["read", "write"]): "editor",
    frozenset(["read"]):          "viewer",
}
user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # editor

Quando usar frozenset: sempre que você precisar de um objeto semelhante a um set que não deve mudar — como uma configuração constante, uma chave de dicionário segura, ou ao compartilhar um set entre threads sem bloqueio.

Exemplos Práticos

Remover duplicatas de uma lista

Converter para um set e de volta é a forma mais simples de deduplicar uma lista. Note que a ordem original não é preservada; se a ordem importar, use dict.fromkeys() em vez disso.

Remover duplicatas de uma lista usando um set em Python

Verificar se duas listas compartilham algum elemento

Verificar se duas listas têm elementos em comum em Python usando sets

isdisjoint() é uma alternativa mais direta para esta verificação:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(not set(list1).isdisjoint(set(list2)))  # False — no common elements

Encontrar tags únicas entre artigos

article_a_tags = {"python", "tutorial", "beginner"}
article_b_tags = {"python", "advanced", "data-science"}

all_tags    = article_a_tags | article_b_tags
shared_tags = article_a_tags & article_b_tags
only_in_a   = article_a_tags - article_b_tags

print("All tags:    ", all_tags)
print("Shared tags: ", shared_tags)
print("Only in A:   ", only_in_a)

Resumo

Capítulos relacionados: Adicionar Itens ao Set · Remover Itens de Set · Acessar Itens de Set · Iterar Sets · Unir Sets · Métodos de Set

Prática