Trabalhar com Conjuntos (Sets) em Python

PythonBeginner
Pratique Agora

Introdução

Neste laboratório, você ganhará experiência prática com conjuntos (sets) em Python. Conjuntos são uma estrutura de dados fundamental usada para armazenar elementos únicos e não ordenados. Eles são altamente eficientes para tarefas como verificar se um elemento está presente em uma coleção e para realizar operações matemáticas de conjuntos.

Você aprenderá a criar conjuntos, adicionar e remover elementos, e realizar operações comuns como união (union), interseção (intersection) e diferença (difference). Finalmente, você verá uma aplicação prática de conjuntos ao usá-los para remover facilmente itens duplicados de uma lista.

Criar e Adicionar Elementos a um Conjunto

Nesta primeira etapa, você aprenderá a criar conjuntos (sets) e a adicionar novos elementos a eles. Conjuntos são coleções de itens únicos, o que significa que eles descartam automaticamente quaisquer duplicatas.

Seu ambiente inclui um arquivo vazio chamado set_basics.py. Usando o explorador de arquivos no lado esquerdo do editor, localize e abra ~/project/set_basics.py.

Adicione o seguinte código Python ao arquivo. Este código demonstra várias maneiras de criar um conjunto.

## Método 1: Usando chaves {}
## Isso cria um conjunto com elementos iniciais.
my_set = {'apple', 'banana', 'cherry'}
print("Set criado com chaves:", my_set)
print("Tipo de my_set:", type(my_set))

## Nota: Conjuntos removem automaticamente elementos duplicados.
duplicate_set = {'apple', 'banana', 'apple'}
print("Conjunto com duplicatas:", duplicate_set)

## Método 2: Usando o construtor set() em um iterável (como uma string)
## Isso cria um conjunto a partir dos caracteres únicos na string.
char_set = set('hello world')
print("Conjunto a partir de uma string:", char_set)

## Método 3: Criando um conjunto vazio
## Você deve usar set() para criar um conjunto vazio. {} cria um dicionário vazio.
empty_set = set()
print("Um conjunto vazio:", empty_set)
print("Tipo de empty_set:", type(empty_set))

Salve o arquivo. Agora, abra um terminal no seu editor (você pode usar o menu: Terminal -> New Terminal) e execute seu script com o seguinte comando.

python ~/project/set_basics.py

Você verá uma saída semelhante à seguinte. Observe que a ordem dos elementos em um conjunto não é garantida e as duplicatas são removidas.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

Em seguida, vamos adicionar novos elementos a um conjunto existente. Você pode adicionar um único elemento com o método add() ou múltiplos elementos com o método update().

Adicione o seguinte código ao final do seu arquivo set_basics.py.

## --- Adicionando elementos ---
fruits = {'apple', 'banana'}
print("\nConjunto original de frutas:", fruits)

## Use add() para adicionar um único elemento
fruits.add('orange')
print("Após adicionar 'orange':", fruits)

## add() não tem efeito se o elemento já estiver presente
fruits.add('apple')
print("Após adicionar 'apple' novamente:", fruits)

## Use update() para adicionar múltiplos elementos de um iterável (como uma lista)
fruits.update(['mango', 'grape'])
print("Após atualizar com uma lista:", fruits)

Salve o arquivo novamente e execute o script atualizado no terminal.

python ~/project/set_basics.py

A saída agora incluirá os resultados da adição de elementos.

Set created with braces: {'cherry', 'apple', 'banana'}
Type of my_set: <class 'set'>
Set with duplicates: {'banana', 'apple'}
Set from a string: {'d', 'l', 'o', 'r', 'w', ' ', 'h', 'e'}
An empty set: set()
Type of empty_set: <class 'set'>

Original fruits set: {'banana', 'apple'}
After adding 'orange': {'banana', 'orange', 'apple'}
After adding 'apple' again: {'banana', 'orange', 'apple'}
After updating with a list: {'grape', 'mango', 'banana', 'orange', 'apple'}

Você aprendeu agora como criar conjuntos e modificá-los adicionando novos elementos.

Remover Elementos de um Conjunto

Nesta etapa, você aprenderá várias maneiras de remover elementos de um conjunto. Como os conjuntos não são ordenados, você não pode usar um índice para remover itens. Em vez disso, Python fornece métodos específicos para esse fim.

Localize e abra o arquivo set_removal.py no seu diretório ~/project.

Adicione o seguinte código ao arquivo. Ele demonstra os métodos remove(), discard(), pop() e clear().

## --- Removendo elementos ---
my_set = {'a', 'b', 'c', 'd', 'e'}
print("Conjunto original:", my_set)

## Método 1: remove()
## Remove um elemento especificado. Gera um KeyError se o elemento não for encontrado.
my_set.remove('b')
print("Após remover 'b':", my_set)
## A linha a seguir causaria um erro: my_set.remove('z')

## Método 2: discard()
## Também remove um elemento especificado, mas NÃO gera um erro se o elemento não for encontrado.
print("\nConjunto inicial para discard:", my_set)
my_set.discard('c')
print("Após descartar 'c':", my_set)
my_set.discard('z') ## 'z' não está no conjunto, mas nenhum erro ocorre.
print("Após descartar 'z' (inexistente):", my_set)

## Método 3: pop()
## Remove e retorna um elemento arbitrário do conjunto.
## Como os conjuntos não são ordenados, você não sabe qual item será removido.
print("\nConjunto inicial para pop:", my_set)
popped_item = my_set.pop()
print("Item removido (popped):", popped_item)
print("Conjunto após pop():", my_set)

## Método 4: clear()
## Remove todos os elementos do conjunto, deixando um conjunto vazio.
print("\nConjunto inicial para clear:", my_set)
my_set.clear()
print("Conjunto após clear():", my_set)

Salve o arquivo. Agora, execute o script no seu terminal.

python ~/project/set_removal.py

Sua saída deve ser semelhante a esta. O elemento removido por pop() pode ser diferente a cada vez que você executa o script, pois os conjuntos não são ordenados.

Original set: {'d', 'c', 'e', 'a', 'b'}
After removing 'b': {'d', 'c', 'e', 'a'}

Starting set for discard: {'d', 'c', 'e', 'a'}
After discarding 'c': {'d', 'e', 'a'}
After discarding 'z' (non-existent): {'d', 'e', 'a'}

Starting set for pop: {'d', 'e', 'a'}
Popped item: d
Set after pop(): {'e', 'a'}

Starting set for clear: {'e', 'a'}
Set after clear(): set()

Você agora conhece os métodos principais para remover elementos de um conjunto e entende a diferença importante entre remove() e discard().

Realizar Operações de Conjunto

Conjuntos são particularmente poderosos para realizar operações matemáticas como união, interseção e diferença. Nesta etapa, você aprenderá como realizar essas operações em Python.

Localize e abra o arquivo set_operations.py no seu diretório ~/project.

Adicione o seguinte código ao arquivo. Este código define dois conjuntos e, em seguida, realiza as três principais operações de conjunto sobre eles.

set_a = {'a', 'b', 'c', 'd'}
set_b = {'c', 'd', 'e', 'f'}

print("Conjunto A:", set_a)
print("Conjunto B:", set_b)

## --- União (Union) ---
## A união contém todos os elementos únicos de ambos os conjuntos.
## Você pode usar o operador | ou o método .union().
union_set_op = set_a | set_b
union_set_method = set_a.union(set_b)
print("\nUnião com operador |:", union_set_op)
print("União com método .union():", union_set_method)

## --- Interseção (Intersection) ---
## A interseção contém apenas os elementos que são comuns a ambos os conjuntos.
## Você pode usar o operador & ou o método .intersection().
intersection_set_op = set_a & set_b
intersection_set_method = set_a.intersection(set_b)
print("\nInterseção com operador &:", intersection_set_op)
print("Interseção com método .intersection():", intersection_set_method)

## --- Diferença (Difference) ---
## A diferença contém elementos que estão no primeiro conjunto, mas NÃO no segundo conjunto.
## Você pode usar o operador - ou o método .difference().
difference_set_op = set_a - set_b
difference_set_method = set_a.difference(set_b)
print("\nDiferença (A - B) com operador -:", difference_set_op)
print("Diferença (A - B) com método .difference():", difference_set_method)

## Note que a ordem é importante para a diferença
difference_b_a = set_b - set_a
print("Diferença (B - A):", difference_b_a)

Salve o arquivo e execute-o a partir do terminal.

python ~/project/set_operations.py

A saída mostrará claramente os resultados de cada operação.

Set A: {'d', 'c', 'a', 'b'}
Set B: {'d', 'c', 'f', 'e'}

Union with | operator: {'d', 'c', 'f', 'e', 'a', 'b'}
Union with .union() method: {'d', 'c', 'f', 'e', 'a', 'b'}

Intersection with & operator: {'d', 'c'}
Intersection with .intersection() method: {'d', 'c'}

Difference (A - B) with - operator: {'a', 'b'}
Difference (A - B) with .difference() method: {'a', 'b'}
Difference (B - A): {'f', 'e'}

Você utilizou com sucesso tanto os símbolos de operador quanto os métodos para realizar operações de união, interseção e diferença em conjuntos.

Usar um Conjunto para Remover Duplicatas de uma Lista

Um dos usos mais comuns e práticos de conjuntos é remover rapidamente elementos duplicados de uma lista. Como os conjuntos só podem conter elementos únicos, converter uma lista em um conjunto e depois de volta para uma lista é uma maneira simples e eficiente de conseguir isso.

Localize e abra o arquivo final para este laboratório, remove_duplicates.py, no seu diretório ~/project.

Adicione o seguinte código ao arquivo.

## Uma lista contendo vários números duplicados
numbers_list = [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
print("Lista original com duplicatas:", numbers_list)

## Passo 1: Converter a lista em um conjunto (set).
## Isso remove automaticamente todos os elementos duplicados.
unique_numbers_set = set(numbers_list)
print("Conjunto criado a partir da lista (duplicatas removidas):", unique_numbers_set)

## Passo 2: Converter o conjunto de volta para uma lista (list).
## A nova lista conterá apenas os elementos únicos.
unique_numbers_list = list(unique_numbers_set)
print("Lista final com duplicatas removidas:", unique_numbers_list)

## Nota: Este processo não preserva a ordem original dos elementos
## porque conjuntos são uma estrutura de dados não ordenada.

Salve o arquivo e execute-o a partir do terminal.

python ~/project/remove_duplicates.py

A saída demonstra todo o processo, mostrando a lista original, o conjunto intermediário e a lista final, sem duplicatas.

Original list with duplicates: [1, 5, 2, 3, 5, 1, 4, 2, 2, 5]
Set created from list (duplicates gone): {1, 2, 3, 4, 5}
Final list with duplicates removed: [1, 2, 3, 4, 5]

Você aplicou com sucesso seu conhecimento sobre conjuntos para resolver um problema comum de programação: remover duplicatas de uma lista.

Resumo

Neste laboratório, você aprendeu as habilidades essenciais para trabalhar com conjuntos (sets) em Python. Você começou criando conjuntos usando diferentes sintaxes e aprendeu como eles impõem inerentemente a unicidade. Você praticou a modificação de conjuntos adicionando elementos com add() e update(), e removendo-os com remove(), discard(), pop() e clear(), observando as principais diferenças entre esses métodos.

Além disso, você explorou as operações matemáticas centrais de conjuntos — união (|), interseção (&) e diferença (-) — que são fundamentais para a análise de dados e o design de algoritmos. Finalmente, você colocou esse conhecimento em prática implementando uma técnica elegante para remover itens duplicados de uma lista, uma tarefa comum na limpeza e preparação de dados. Agora você está apto a usar conjuntos de forma eficaz em seus programas Python.