Sets no Python

✅ Atualizado para Python 3.13 (Dezembro 2025)
Conteúdo enriquecido com casos práticos, operações de conjuntos e comparação set vs frozenset.

Olá Pythonista!

Sets são coleções não-ordenadas e sem duplicatas com lookups O(1). Perfeitos para remover duplicatas, testes de membresía e operações matemáticas de conjuntos!

Neste guia, você vai aprender:

• ✅ Criação e operações básicas
• ✅ Operações de conjuntos (união, interseção, diferença)
• ✅ Casos de uso reais (remove duplicatas, validação)
• ✅ set vs frozenset - quando usar cada um

Sem mais delongas, vamos para o conteúdo!

Vá Direto ao Assunto…

• Introdução
• Dados duplicados
• Adicionando itens
• Acessando itens
• Removendo itens
• Operações matemáticas com sets
• Set Comprehensions ou Compreensão de Sets
• Casos de Uso Reais
• set vs frozenset

Introdução

O Set é um tipo de dado bastante peculiar do Python que possui as seguintes características:

• Sets são desordenados
• Não possuem elementos duplicados, ou seja, cada elemento é único.
• Um set em si pode ser modificado, contudo os elementos contidos dentro dele precisam ser de tipos imutáveis.

A sintaxe para utilizar sets é bem simples: eles são definidos utilizando-se chaves {}. Veja um exemplo:

1

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

Para confirmar seu tipo:

1
2
3

meu_set = {'python', 'academy'}

print(type(meu_set))

A saída do código acima será:

1

<class 'set'>

Portanto, caso em algum momento você se depare com esse objeto, saiba que ele é um Set!

Dados duplicados

Como dito na introdução os dados no Sets não podem ser duplicados.

Vamos ver um exemplo para confirmar:

1
2
3
4
5

lista = [1, 1, 2, 2, 3, 3]

sem_duplicados = set(lista)

print(sem_duplicados)

Observe como os valores duplicados são ignorados:

1

{1, 2, 3}

Adicionando itens

Após a criação de um Set, você não pode alterar seus itens.

Contudo você pode adicionar novos itens e para isso podemos utilizar o método add().

Vamos ver como:

1
2
3
4
5

convidados = {'João', 'Maria', 'Eduarda'}

convidados.add('Marcela')

print(convidados)

A chamada ao método add() adiciona o elemento ‘Marcela’ ao set:

1

{'Eduarda', 'Maria', 'Marcela', 'João'}

Para adicionar itens de outro conjunto ao set especificado, podemos utilizar o método update().

Você pode utilizar esse método com qualquer tipo de objeto iterável (tuplas, listas, dicionários etc.)

1
2
3
4
5
6
7

ids = {10, 12, 13, 14}

novos_ids = {11, 13, 15}

ids.update(novos_ids)

print(ids)

Veja como o set ids ficou após a chamada ao método update():

1

{10, 11, 12, 13, 14, 15}

Acessando itens

Sets não possibilitam acessar seus elementos através de índices (assim como Listas) ou chaves (como os Dicionários).

Veja o que acontece caso tentemos realizar essa operação:

1
2
3

set_1 = {1, 2, 3}

print(set_1[0])

Saída:

1
2
3

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing

Assim, podemos acessá-los de duas maneiras “brutas”: percorrendo o conjunto ou verificando se o elemento desejado se encontra no set.

Podemos percorrer seus elementos com for, por exemplo:

1
2
3
4

este_set = {'João', 'Maria', 'Eduarda'}

for item in este_set:
    print(item)

Sendo impresso seu conteúdo:

1
2
3

João
Maria
Eduarda

Ou verificando se um elemento existe dentro dele:

1

print('João' in este_set)

Imprimindo True ou False, de acordo com o resultado da condição estabelecida.

Poxa, poucas maneiras de acessar os elementos, hein?

Calma, não entre em pânico! Podemos transformar o set em lista para ganharmos as facilidades de manipulação das Listas:

1
2
3
4

lista = list(este_set)
print(lista[0])
print(lista[1])
print(lista[2])

Saída:

1
2
3

João
Maria
Eduarda

Caso você queria saber tudo sobre Listas, vale dar uma olhada no nosso post completo sobre listas!

Removendo itens

Para remover itens de um set, você pode, inicialmente, utilizar dois métodos: o remove() e discard().

Veja como é simples remover elementos com remove():

1
2
3

sacola = {'queijo', 'pão', 'leite'}

sacola.remove('queijo')

Para remover com discard(), faça:

1
2
3

sacola = {'queijo', 'pão', 'leite'}

sacola.discard('queijo')

Ambos terão o mesmo resultado:

1

{'pão', 'leite'}

Caso o item não exista, será gerado um erro do tipo TypeError!

Você também pode usar o método pop(), porém no caso do set ele não removerá o último item (pois o conjunto é desordenado):

1
2
3
4
5
6

compra = {'queijo', 'pão', 'leite'}

item = compra.pop()

print(f"Item removido: {item}")
print(compra)

Ou seja, a saída pode ser um item completamente aleatório:

1
2

Item removido: pão
{'queijo', 'leite'}

Se você deseja esvaziar completamente o set, utilize o clear():

1
2
3

compra = {'queijo', 'pão', 'leite'}

compra.clear()

O que fará com que o set compra fique vazio ({}).

Podemos deletá-lo completamente, utilizando a keyword del do Python, assim:

1
2
3

compra = {'queijo', 'pão', 'leite'}

del compra

Estou construindo o DevBook, uma plataforma que usa IA para criar ebooks técnicos — com código formatado e exportação em PDF. Te convido a conhecer!

Operações matemáticas com sets

Agora é hora de relembrar suas aulas de Matemática!

Muita das vezes você pode pensar que os sets são bem restritos, porém sua utilização para armazenar elementos distintos é incrívelmente útil.

Os Sets em Python nada mais são que Conjuntos Matemáticos. Neles, você também pode aplicar os conceitos de Interseção, União, Diferença e etc.

Interseção

O método intersection() retorna um novo conjunto contendo apenas os itens presentes em ambos:

1
2
3
4
5
6
7

sacola1 = {'Banana', 'Maça', 'Abacate'}
sacola2 = {'Laranja', 'Pera', 'Maça'}

sacola = sacola1.intersection(sacola2)
print(sacola)
# ou
print(sacola1 & sacola2)

Resultando em:

1
2

{'Maça'}
{'Maça'}

Se você deseja já atualizar um dos sets com a interseção entre eles, use o método intersection_update():

1
2
3
4
5
6

sacola1 = {'Banana', 'Maça', 'Abacate'}
sacola2 = {'Laranja', 'Pera', 'Maça'}

sacola1.intersection_update(sacola2)

print(sacola1)

Veja que sacola1 agora possui apenas a interseção entre os sets:

1

{'Maça'}

União

Você pode utilizar o método union() para retornar um conjunto de elementos contendo elemento de ambos sets:

1
2
3
4
5
6

set1 = {1, 2, 3}
set2 = {'z', 'x', 'a'}

print(set1.union(set2))
# ou 
print(set1 | set2)

Resultando na união dos sets em um novo conjunto:

1
2

{'x', 1, 2, 3, 'z', 'a'}
{'x', 1, 2, 3, 'z', 'a'}

Diferença

o método difference() retorna a diferença, ou seja os valores que existem no set sacola1, e não no set sacola2:

1
2
3
4
5
6

sacola1 = {'Banana', 'Maça'}
sacola2 = {'Laranja', 'Pera', 'Maça'}

print(sacola1.difference(sacola2))
# ou
print(sacola1 - sacola2)

Resultando apenas nos itens que estão contidos no set sacola1:

1
2

{'Banana'}
{'Banana'}

Diferença simétrica

O método symmetric_difference_update() manterá os elementos que não estão presentes em ambos conjuntos:

1
2
3
4
5
6

sacola1 = {'Banana', 'Maça'}
sacola2 = {'Laranja', 'Pera', 'Maça'}

print(sacola1.symmetric_difference(sacola2))
# ou
print(sacola1 ^ sacola2)

Apenas os dados que não estão presentes em ambos os sets estarão:

1
2

{'Laranja', 'Banana', 'Pera'}
{'Laranja', 'Banana', 'Pera'}

Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Set Comprehensions ou Compreensão de Sets

Existe uma forma muito Pythônica de se criar sets, através da técnica chamada Set Comprehensions.

Ele é uma maneira muito concisa de se criar e manipular sets que a Linguagem nos oferece!

Se você quiser saber tudo sobre esse assunto, acesse agora nosso post completo sobre Set Comprehensions AGORA!

Casos de Uso Reais

1. Remover Duplicatas de Lista

1
2
3
4
5
6
7

# Manter elementos únicos
emails = ['[email protected]', '[email protected]', '[email protected]']
unique_emails = list(set(emails))
print(unique_emails)  # ['[email protected]', '[email protected]']

# Preservar ordem (Python 3.7+)
unique_ordered = list(dict.fromkeys(emails))

2. Validação de Permissões

1
2
3
4
5
6
7
8
9
10
11

user_permissions = {'read', 'write', 'delete'}
required_permissions = {'read', 'write'}

# Verificar se usuário tem todas as permissões
has_access = required_permissions.issubset(user_permissions)
print(has_access)  # True

# Permissões faltando
missing = required_permissions - user_permissions
if missing:
    print(f"Faltam: {missing}")

3. Comparar Listas

1
2
3
4
5
6
7
8
9
10
11
12
13
14

old_users = {'alice', 'bob', 'charlie'}
new_users = {'bob', 'charlie', 'dave'}

# Novos usuários
added = new_users - old_users
print(f"Adicionados: {added}")  # {'dave'}

# Usuários removidos
removed = old_users - new_users
print(f"Removidos: {removed}")  # {'alice'}

# Usuários que permaneceram
stayed = old_users & new_users
print(f"Permaneceram: {stayed}")  # {'bob', 'charlie'}

4. Filtrar Elementos Comuns

1
2
3
4
5
6
7
8
9
10
11

# Tags de 2 posts de blog
post1_tags = {'python', 'tutorial', 'web'}
post2_tags = {'python', 'data', 'tutorial'}

# Tags em comum
common_tags = post1_tags & post2_tags
print(common_tags)  # {'python', 'tutorial'}

# Todas as tags
all_tags = post1_tags | post2_tags
print(all_tags)  # {'python', 'tutorial', 'web', 'data'}

set vs frozenset

Exemplo Prático

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# set: Mutável
tags = {'python', 'web'}
tags.add('tutorial')  # ✅ Pode modificar

# frozenset: Imutável
frozen_tags = frozenset(['python', 'web'])
# frozen_tags.add('tutorial')  # ❌ Erro!

# Use frozenset como chave de dict
cache = {}
key = frozenset(['param1', 'param2'])
cache[key] = "resultado"

# Use frozenset como elemento de set
set_of_sets = {frozenset([1, 2]), frozenset([3, 4])}

Conclusão

Neste guia completo sobre Sets, você aprendeu:

✅ Operações básicas - Criar, adicionar, remover
✅ Operações de conjuntos - União, interseção, diferença
✅ Casos práticos - Remover duplicatas, validação, comparações
✅ set vs frozenset - Mutável vs imutável

Principais lições:

• Sets não têm duplicatas (automático!)
• Lookups O(1) - tão rápido quanto dict
• Use | (união), & (interseção), - (diferença)
• frozenset é imutável e hasheável
• Sets não são ordenados (ordem imprevisível)

Próximos passos:

• Pratique set comprehensions
• Explore métodos .issubset(), .issuperset()
• Aprenda .symmetric_difference() (XOR)
• Estude frozenset para dados imutáveis

Nesse Post vimos do básico ao avançado sobre os Sets do Python!

Se ficou com alguma dúvida, fique à vontade para deixar um comentário no box aqui embaixo! Será um prazer te responder!

Por Erickson Lopes em 02/07/2021

O infinito é o limite

Bora se conectar no LinkedIn! ericksonlopes

Minhas redes: