Sets (conjuntos) em Python: Guia Completo com Exemplos

✅ Artigo atualizado em Setembro 2026 Novas seções sobre como criar um set (e a pegadinha do {}), tabela de operações com operadores e métodos, busca O(1) com in e comparação com lista, tupla e dicionário, além de erros comuns com traceback e 8 exercícios resolvidos.

1
2
3
4
5
6

numeros = {3, 1, 3, 2}       # a duplicata some
print(numeros)               # {1, 2, 3}
numeros.add(4)               # adicionar
print(2 in numeros)          # True (busca O(1))
print({1, 2} | {2, 3})       # {1, 2, 3} (união)
vazio = set()                # {} cria um dict, não um set!

Olá Pythonista!

Sets são coleções não ordenadas e sem duplicatas com buscas O(1). Perfeitos para remover duplicatas, testar se um elemento pertence à coleção e fazer operações matemáticas de conjuntos!

Neste guia, você vai aprender:

• ✅ Como criar um set (e por que {} não é um set vazio)
• ✅ Operações de conjuntos (união, interseção, diferença, diferença simétrica)
• ✅ Casos de uso reais (remover duplicatas, validação)
• ✅ set vs frozenset e set vs lista, tupla e dicionário
• ✅ Erros comuns e exercícios resolvidos

Sem mais delongas, vamos para o conteúdo!

Vá Direto ao Assunto…

• Introdução
• Como criar um set (conjunto) em Python
• 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
• Set é mais rápido que lista? Busca O(1) com in
• Set, lista, tupla ou dicionário: quando usar cada um
• Erros comuns
• Exercícios resolvidos

Introdução

O que é um set em Python? Set (conjunto) é um tipo nativo do Python que guarda elementos únicos, sem ordem e sem índice. É criado com chaves, como {1, 2, 3}, ou com set(), e serve para remover duplicatas, testar pertinência com in em tempo O(1) e fazer união, interseção e diferença.

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.

Ele é um dos tipos de dados nativos do Python, ao lado de listas, tuplas e dicionários, e a referência oficial está na documentação do Python sobre os tipos set e frozenset.

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!

Como criar um set (conjunto) em Python

Há duas formas de criar um conjunto: escrevendo os elementos entre chaves ou passando qualquer iterável (lista, tupla, string, range) para a função set():

1
2
3
4
5
6
7
8
9
10
11

a = {1, 2, 3}                # literal com chaves
b = set([1, 2, 2, 3])        # a partir de uma lista
c = set('banana')            # a partir de uma string
d = set(range(5))            # a partir de um range
e = set()                    # conjunto vazio

print(a)
print(b)
print(sorted(c))
print(d)
print(e)

Saída:

1
2
3
4
5

{1, 2, 3}
{1, 2, 3}
['a', 'b', 'n']
{0, 1, 2, 3, 4}
set()

Repare que set('banana') quebra a string em letras e guarda só as distintas (a, b e n). Usamos sorted() para imprimir porque a ordem de um set de strings muda de uma execução para outra.

A pegadinha: chaves vazias criam um dicionário

As chaves vazias {} não criam um set: elas criam um dicionário vazio, porque os dicionários chegaram primeiro à linguagem. Para um conjunto vazio, use sempre set():

1
2
3
4
5

x = {}
y = set()

print(type(x))
print(type(y))

Saída:

1
2

<class 'dict'>
<class 'set'>

Essa é uma das questões de prova mais comuns sobre conjuntos. Repare também que o próprio Python imprime um set vazio como set(), e não como {}.

Quais elementos um set aceita

Os elementos de um set precisam ser imutáveis (tecnicamente, hashable): números, strings, tuplas e frozenset. Listas, dicionários e outros sets não podem entrar:

1
2
3
4

ok = {1, 'dois', (3, 4), frozenset({5})}
print(len(ok))  # 4

ruim = {1, [2, 3]}

1

TypeError: unhashable type: 'list'

Se precisar guardar uma sequência dentro do set, troque a lista por uma tupla: {1, (2, 3)}.

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 (a ordem de impressão pode variar a cada execução, já que sets não têm ordem):

1

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

Se o elemento já existir, add() simplesmente não faz nada: nenhum erro é gerado e nada é duplicado.

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}

Atenção à diferença entre os dois métodos: add() insere o objeto inteiro como um elemento, enquanto update() percorre o iterável e insere cada item. Com uma string, isso fica bem visível:

1
2
3
4
5
6
7

letras = set()
letras.add('abc')
print(letras)

letras = set()
letras.update('abc')
print(sorted(letras))

Saída:

1
2

{'abc'}
['a', 'b', 'c']

Resumindo para a prova: o método para adicionar um valor a um conjunto é add(); para adicionar vários, update().

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 is not subscriptable

Isso acontece porque um set não tem ordem: não existe “primeiro” nem “último” elemento. Cuidado com uma ilusão comum: sets de inteiros pequenos costumam aparecer ordenados, mas é só coincidência da implementação:

1
2

print({3, 1, 2})
print({30, 1, 200})

Saída:

1
2

{1, 2, 3}
{200, 1, 30}

Nunca escreva código que dependa da ordem de um set. Se precisar de ordem, use sorted(meu_set), que devolve uma lista ordenada.

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 (em uma ordem que pode mudar a cada execução):

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. Esse teste com in é justamente o ponto forte dos sets: ele é O(1), como você vai ver na seção sobre busca O(1) com in.

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 (lembrando que a ordem da lista herda a ordem imprevisível do set; use sorted(este_set) se precisar de uma ordem garantida):

1
2
3

João
Maria
Eduarda

Caso você queira 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'}

A diferença aparece quando o item não existe: discard() não faz nada, enquanto remove() lança um KeyError:

1
2
3
4
5
6

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

sacola.discard('vinho')   # não faz nada
print(len(sacola))        # 3

sacola.remove('vinho')

1

KeyError: 'vinho'

Use remove() quando a ausência do item indicar um bug que você quer ver estourar, e discard() quando tanto faz se ele estava lá.

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 (o Python o exibe como set(), já que {} seria um dicionário).

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

1
2
3

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

del compra

Resumo dos métodos para remover elementos de um conjunto:

Estou desenvolvendo o Ebookr.ai, uma plataforma que transforma suas ideias em ebooks profissionais usando IA - com geração de capa, infográficos e exportação em PDF. Te convido a conhecer!

Operações matemáticas com sets

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

Muitas vezes você pode pensar que os sets são bem restritos, porém sua utilização para armazenar elementos distintos é incrivelmente ú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.

Cada operação pode ser feita com um operador ou com um método. Tabela de referência, usando a = {1, 2, 3} e b = {3, 4}:

Duas diferenças práticas entre operador e método: os métodos aceitam qualquer iterável ({1, 2}.union([2, 3]) funciona), enquanto os operadores exigem que os dois lados sejam sets ({1, 2} | [2, 3] gera TypeError: unsupported operand type(s) for |: 'set' and 'list'). E a diferença não é comutativa: a - b é {1, 2}, mas b - a é {4}.

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() (ou o operador ^) retorna os elementos que estão em apenas um dos conjuntos, ou seja, tudo menos a interseção:

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

Assim como intersection_update(), cada operação tem uma versão que altera o set no lugar em vez de criar um novo: update() (|=), intersection_update() (&=), difference_update() (-=) e symmetric_difference_update() (^=):

1
2
3
4
5
6
7
8
9

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

Saída:

1
2
3
4

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

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! Veja um exemplo que gera os quadrados de 0 a 4:

1
2

quadrados = {x ** 2 for x in range(5)}
print(quadrados)  # {0, 1, 4, 9, 16}

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
8

# Manter elementos únicos
emails = ['[email protected]', '[email protected]', '[email protected]']
unique_emails = list(set(emails))
print(unique_emails)  # 2 e-mails, em ordem imprevisível

# Preservar ordem (Python 3.7+)
unique_ordered = list(dict.fromkeys(emails))
print(unique_ordered)  # ['[email protected]', '[email protected]']

Existem três jeitos de remover duplicatas, e a escolha depende do que você precisa fazer com a ordem:

1
2
3
4
5
6
7
8
9
10

nomes = ['Caio', 'Ana', 'Caio', 'Bia', 'Ana']

# 1) Sem se importar com a ordem
print(len(set(nomes)))

# 2) Mantendo a ordem da primeira aparição
print(list(dict.fromkeys(nomes)))

# 3) Em ordem alfabética
print(sorted(set(nomes)))

Saída:

1
2
3

3
['Caio', 'Ana', 'Bia']
['Ana', 'Bia', 'Caio']

O dict.fromkeys() funciona porque as chaves de um dicionário também são únicas e, diferente do set, o dict mantém a ordem de inserção. Se além de remover você quer contar quantas vezes cada item aparece, use o Counter do pacote collections. E para mais técnicas de manipulação (ordenar, filtrar, inverter), veja o guia de manipulação de listas no Python.

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'} (em qualquer ordem)

set vs frozenset

O frozenset é a versão imutável do set: é criado com frozenset(iterável), suporta as mesmas operações de conjunto (união, interseção, diferença), mas não tem add(), remove() nem qualquer método que altere seu conteúdo. Em troca, ele é hashable e pode ser chave de dicionário ou elemento de outro set.

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')  # ❌ AttributeError: 'frozenset' object has no attribute 'add'

# 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])}

Set é mais rápido que lista? Busca O(1) com in

Sim, para testar se um elemento existe. Numa lista, x in lista compara item por item até achar (O(n)): quanto maior a lista, mais lento. Num set, x in meu_set calcula o hash de x e vai direto à posição dele (O(1) em média), não importa o tamanho do conjunto. Veja a diferença com um milhão de números:

1
2
3
4
5
6
7
8
9
10

import timeit

dados_lista = list(range(1_000_000))
dados_set = set(dados_lista)

tempo_lista = timeit.timeit(lambda: 999_999 in dados_lista, number=100)
tempo_set = timeit.timeit(lambda: 999_999 in dados_set, number=100)

print(f"lista: {tempo_lista:.4f} s")
print(f"set:   {tempo_set:.6f} s")

Resultado de uma execução com Python 3.10 (os números variam de máquina para máquina, mas a diferença de ordens de grandeza se mantém):

1
2

lista: 0.5343 s
set:   0.000010 s

Na prática: sempre que você tiver um laço que pergunta “este item está nesta coleção?” muitas vezes, converta a coleção de referência para set uma vez só, antes do laço:

1
2
3
4
5

bloqueados = {'[email protected]', '[email protected]', '[email protected]'}
cadastros = ['[email protected]', '[email protected]', '[email protected]']

validos = [email for email in cadastros if email not in bloqueados]
print(validos)  # ['[email protected]', '[email protected]']

O custo é memória: um set ocupa mais espaço que uma lista com os mesmos itens, e converter uma lista em set também leva tempo O(n). Por isso a conversão só compensa quando você vai fazer várias buscas.

Saber quando usar cada estrutura é o tipo de intuição que só vem com prática de verdade - e é isso que você treina, do zero ao avançado, na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Set, lista, tupla ou dicionário: quando usar cada um

Os quatro são coleções nativas do Python, mas cada um resolve um problema diferente:

Regra de bolso: se a pergunta é “qual é o item na posição X?”, use lista ou tupla; se é “este item existe?” ou “quais itens são diferentes?”, use set; se é “qual o valor associado a esta chave?”, use dicionário. É comum combinar: guardar os dados numa lista e montar um set só para as verificações.

Erros comuns

Estes são os erros que mais aparecem com sets, com a mensagem real que o Python mostra.

Colocar uma lista dentro do set (TypeError: unhashable type: 'list')

1
2

numeros = {1, 2, 3}
numeros.add([4, 5])

1

TypeError: unhashable type: 'list'

Correção: elementos de set precisam ser imutáveis. Para adicionar os itens da lista, use update(); para guardar a sequência como um elemento só, use uma tupla:

1
2
3
4

numeros = {1, 2, 3}
numeros.update([4, 5])     # adiciona 4 e 5
numeros.add((6, 7))        # a tupla inteira vira um elemento
print(numeros)             # {1, 2, 3, 4, 5, (6, 7)}

Remover um item que não existe (KeyError)

1
2

sacola = {'queijo', 'pão', 'leite'}
sacola.remove('vinho')

1

KeyError: 'vinho'

Correção: use sacola.discard('vinho'), que não gera erro quando o item está ausente, ou teste antes com if 'vinho' in sacola:. O mesmo KeyError aparece em pop() com o set vazio (KeyError: 'pop from an empty set').

Acessar por índice (TypeError: 'set' object is not subscriptable)

1
2

cores = {'azul', 'verde', 'rosa'}
print(cores[0])

1

TypeError: 'set' object is not subscriptable

Correção: set não tem posição. Se você precisa de um item específico, converta para uma lista ordenada com sorted(cores)[0] (que devolve 'azul'), ou use uma lista desde o início.

Criar o set vazio com {} (AttributeError)

1
2

x = {}
x.add(1)

1

AttributeError: 'dict' object has no attribute 'add'

Correção: {} é um dicionário vazio. Crie o conjunto vazio com x = set().

Esperar que o set mantenha a ordem

Esse não gera traceback, e por isso é o mais traiçoeiro: list(set(['b', 'a', 'c'])) pode devolver os itens em qualquer ordem, e a ordem de um set de strings pode mudar de uma execução para outra do mesmo programa. Código que faz list(meu_set)[0] esperando “o primeiro item” funciona no seu computador e quebra em produção.

Correção: use sorted(meu_set) quando quiser ordem crescente, ou list(dict.fromkeys(lista)) para remover duplicatas mantendo a ordem original.

Exercícios resolvidos

Tente resolver cada exercício antes de abrir a solução. Todos foram executados no Python 3.10.

Exercício 1. Dada a lista numeros = [5, 3, 5, 1, 3], remova as duplicatas e mostre o resultado em ordem crescente.

1
2

numeros = [5, 3, 5, 1, 3]
print(sorted(set(numeros)))

Exercício 2. A turma de Python tem {'Ana', 'Bia', 'Caio'} e a de Dados tem {'Bia', 'Caio', 'Duda'}. Mostre (em ordem alfabética) quem faz as duas disciplinas, quem faz pelo menos uma e quem faz só Python.

1
2
3
4
5
6

python = {'Ana', 'Bia', 'Caio'}
dados = {'Bia', 'Caio', 'Duda'}

print(sorted(python & dados))
print(sorted(python | dados))
print(sorted(python - dados))

1
2
3

['Bia', 'Caio']
['Ana', 'Bia', 'Caio', 'Duda']
['Ana']

Exercício 3. Quantas letras distintas existem na palavra 'abracadabra'?

1
2

palavra = 'abracadabra'
print(len(set(palavra)))

Exercício 4 (estilo prova). Qual é a saída do código abaixo?

1
2
3
4

s = {1, 2, 3}
s.add(2)
s.add(4)
print(len(s))

a) 5
b) 4
c) 3
d) Um erro, porque 2 já existe no set

Exercício 5 (estilo prova). Qual comando cria um conjunto (set) vazio em Python?

a) x = {}
b) x = set()
c) x = []
d) x = ()

1

print(type({}), type(set()), type([]), type(()))

Exercício 6. Escreva a função unicos_em_ordem(itens) que remove as duplicatas de uma lista mantendo a ordem da primeira aparição, usando um set para lembrar o que já foi visto (sem dict.fromkeys).

1
2
3
4
5
6
7
8
9
10

def unicos_em_ordem(itens):
    vistos = set()
    resultado = []
    for item in itens:
        if item not in vistos:
            vistos.add(item)
            resultado.append(item)
    return resultado

print(unicos_em_ordem(['b', 'a', 'b', 'c', 'a']))

Exercício 7. Escreva a função tem_em_comum(lista1, lista2) que devolve True se as duas listas tiverem pelo menos um elemento em comum.

1
2
3
4
5

def tem_em_comum(lista1, lista2):
    return not set(lista1).isdisjoint(lista2)

print(tem_em_comum([1, 2, 3], [7, 3, 9]))
print(tem_em_comum(['a', 'b'], ['c', 'd']))

1
2

True
False

Exercício 8 (estilo prova). Dados a = {1, 2, 3, 4} e b = {3, 4, 5}, qual expressão resulta em {1, 2, 5}?

a) a & b
b) a - b
c) a ^ b
d) a.union(b)

1
2
3

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

Quer praticar sets, listas e dicionários construindo projetos guiados do zero? Conheça o nosso curso de Python completo, a Jornada Python.

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), ^ (diferença simétrica)
• frozenset é imutável e hasheável
• Sets não são ordenados (ordem imprevisível) e não têm índice
• {} é um dicionário vazio; o set vazio é set()

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:

• 
•