Neste guia, você explorará os fundamentos dos conjuntos em Python, juntamente com os diversos métodos que podem ser empregados para modificar essas estruturas de dados.
Os conjuntos representam uma das estruturas de dados nativas do Python. Eles são particularmente úteis quando se trabalha com coleções de elementos onde a unicidade é um requisito essencial.
Nas próximas seções, examinaremos as bases dos conjuntos em Python e as funcionalidades que eles oferecem, além de aprender como realizar operações de conjunto comuns neste contexto.
Vamos começar!
Entendendo os Conjuntos em Python
Em Python, um conjunto é concebido como uma coleção não ordenada de elementos que não se repetem. Esta característica exige que todos os elementos dentro de um conjunto sejam distintos.
É possível adicionar e remover elementos de um conjunto, o que o qualifica como uma coleção mutável. Conjuntos podem conter elementos de diferentes tipos de dados. No entanto, cada um desses elementos deve ser hashable.
Em Python, um objeto é considerado hashable se seu valor de hash permanece inalterado ao longo do tempo. Objetos imutáveis, como strings, tuplas e dicionários, geralmente são hashable.
Vamos analisar a criação de conjuntos com mais detalhes. Considere os dois exemplos a seguir:
py_set = {0,1,2,(2,3,4),'Legal!'}
py_set = {0,1,2,[2,3,4],'Ops!'}
# Saída
---------------------------------------------------------------------------
TypeError Traceback (mais recente chamada)
<ipython-input-40-2d3716c7fe01> em <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Ops!'}
TypeError: tipo não hashable: 'list'
O primeiro conjunto inclui três números, uma tupla e uma string, e sua criação ocorre sem problemas. Já o segundo, ao tentar incluir uma lista em vez de uma tupla, gera um erro `TypeError`, pois listas são coleções mutáveis e, portanto, não hashable.
Concluindo, um conjunto em Python pode ser definido como uma coleção mutável de elementos distintos e hashable.
Como Criar um Conjunto em Python
Começaremos explorando as maneiras de criar conjuntos em Python.
#1. Usando a Inicialização Explícita
Você pode gerar um conjunto em Python ao especificar os elementos entre chaves `{}`, separados por vírgulas.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Saída
set
Se você já trabalhou com listas em Python, sabe que `[]` é usado para criar listas vazias. Apesar de os conjuntos utilizarem chaves `{}`, usar um par `{}` para inicializar um conjunto vazio resulta na criação de um dicionário e não de um conjunto.
py_set2 = {}
type(py_set2)
# Saída
dict
Usando a função `type()`, podemos confirmar que `py_set2` é, de fato, um dicionário (dict).
#2. Usando a Função `set()`
Para inicializar um conjunto vazio e adicionar elementos posteriormente, você pode usar a função `set()`.
py_set3 = set() type(py_set3) # Saída set
#3. Convertendo Iteráveis em Conjuntos
Outra forma de criar conjuntos é através da conversão de outros iteráveis, como listas e tuplas, usando `set(iterável)`.
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # O elemento repetido 'C' foi removido
type(py_set4)
# set
No exemplo acima, a lista `py_list` continha o elemento ‘C’ duas vezes. Ao converter para o conjunto `py_set4`, ‘C’ aparece apenas uma vez, pois conjuntos só armazenam elementos distintos. Essa técnica é frequentemente empregada para eliminar duplicatas em listas.
Adicionando Elementos a um Conjunto Python
Começaremos com a criação de um conjunto vazio chamado `py_set` e o utilizaremos no restante deste guia.
py_set = set() len(py_set) # Retorna o comprimento de um conjunto # Saída 0
#1. Utilizando o Método `.add()`
Para adicionar elementos a um conjunto, usamos o método `.add()`, cuja sintaxe é `set.add(elemento)`, que adiciona o elemento especificado ao conjunto.
Para melhor compreensão, vamos adicionar elementos ao nosso conjunto `py_set` e exibir o resultado em cada passo.
▶️ Adicionaremos a string ‘Python’ como elemento a `py_set`.
py_set.add('Python')
print(py_set)
# Saída
{'Python'}
Agora, vamos inserir mais um elemento.
py_set.add('C++')
print(py_set)
# Saída
{'Python', 'C++'}
É importante notar que o método `.add()` só adiciona um elemento se ele ainda não existir no conjunto. Caso o elemento já esteja presente, a operação não terá efeito.
Para confirmar, vamos tentar adicionar ‘C++’ novamente a `py_set`.
py_set.add('C++')
print(py_set)
# Saída
{'Python', 'C++'}
O conjunto já contém ‘C++’, portanto, a adição não produz alterações.
▶️ Vamos incluir alguns outros elementos no conjunto.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Saída
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Usando o Método `.update()`
Até agora, vimos como adicionar elementos individualmente a um conjunto.
E se precisarmos adicionar vários elementos de uma vez?
Isso é possível com o método `.update()`, cuja sintaxe é `set.update(coleção)`, que adiciona os elementos da coleção especificada ao conjunto. A coleção pode ser uma lista, tupla ou outro iterável.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Saída
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}
Este método é particularmente útil quando se deseja adicionar múltiplos elementos sem a necessidade de criar objetos temporários.
Na próxima seção, veremos como remover elementos de um conjunto.
Removendo Elementos de um Conjunto Python
Vamos partir do seguinte conjunto (o `py_set` antes da operação de atualização).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
#1. Utilizando o Método `.pop()`
O método `set.pop()` remove e retorna um elemento aleatório do conjunto. Vamos testar esse método em nosso conjunto `py_set` para ver o que é retornado.
py_set.pop() # Saída 'Rust'
Neste caso, a chamada ao método `.pop()` retornou a string ‘Rust’.
Importante: o método `.pop()` retorna um elemento aleatório. Ao executar o código novamente, o elemento retornado poderá ser diferente.
Ao verificar o conjunto, ‘Rust’ não está mais presente.
print(py_set)
# Saída
{'JavaScript', 'Python', 'C++', 'C'}
#2. Usando os Métodos `.remove()` e `.discard()`
Para remover elementos específicos do conjunto, você pode usar os métodos `.remove()` e `.discard()`.
O método `set.remove(elemento)` remove o elemento especificado do conjunto.
py_set.remove('C')
print(py_set)
# Saída
{'JavaScript', 'Python', 'C++'}
Se tentarmos remover um elemento que não está presente no conjunto, encontraremos um `KeyError`.
py_set.remove('Scala')
# Saída
---------------------------------------------------------------------------
KeyError Traceback (mais recente chamada)
<ipython-input-58-a1abab3a8892> em <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'
Verificando novamente `py_set`, temos agora três elementos.
print(py_set)
# Saída
{'JavaScript', 'Python', 'C++'}
Com a sintaxe `set.discard(elemento)`, o método `.discard()` também remove elementos do conjunto.
py_set.discard('C++')
print(py_set)
# Saída
{'JavaScript', 'Python'}
No entanto, ele se diferencia do método `.remove()` por não gerar um `KeyError` quando se tenta remover um elemento inexistente.
Ao tentarmos remover ‘Scala’ (que não existe) do conjunto usando o método `.discard()`, nenhum erro ocorrerá.
py_set.discard('Scala') # sem erro!
print(py_set)
# Saída
{'JavaScript', 'Python'}
Acessando Elementos de um Conjunto Python
Até agora, exploramos como adicionar e remover elementos de conjuntos. No entanto, ainda não vimos como acessar elementos individualmente.
Como conjuntos são coleções não ordenadas, eles não são indexáveis. Tentar acessar elementos através de índice gerará um erro.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Saída
---------------------------------------------------------------------------
TypeError Traceback (mais recente chamada)
<ipython-input-27-0329274f4580> em <module>()
----> 1 print(py_set[0])
TypeError: objeto 'set' não é subscriptable
Como acessar, então, os elementos de um conjunto?
Existem duas formas comuns:
- Percorrer o conjunto com um loop e acessar cada elemento
- Verificar se um determinado elemento pertence ao conjunto
▶️ Percorrer o conjunto com um loop `for`.
for elt in py_set: print(elt) # Saída C++ JavaScript Python Rust C
Para verificar se um determinado elemento está presente no conjunto, usamos o operador `in`.
Importante: `elemento in conjunto` retorna `True` se o elemento está presente no conjunto, caso contrário retorna `False`.
Neste exemplo, `py_set` contém ‘C++’ e não contém ‘Julia’, o que faz com que o operador `in` retorne `True` e `False`, respectivamente.
'C++' in py_set # True 'Julia' in py_set # False
Obtendo o Comprimento de um Conjunto Python
Como visto anteriormente, a função `len()` pode ser usada para obter o número de elementos presentes em um conjunto.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Saída: 5
Limpando um Conjunto Python
Para remover todos os elementos de um conjunto, usamos o método `.clear()`.
Aplicando o método `.clear()` ao nosso conjunto `py_set`.
py_set.clear()
Ao tentar exibir o conjunto, obteremos `set()`, indicando que ele está vazio. A função `len()` também retornará zero, confirmando que o comprimento do conjunto é zero.
print(py_set) # set() print(len(py_set)) # 0
Resumindo, aprendemos a realizar operações básicas em conjuntos Python:
- Criar: com a função `set()`, conversão de tipo e inicialização
- Ler: acessando elementos com loops e o operador `in` para verificar pertinência
- Atualizar: adicionando, removendo e atualizando elementos dos conjuntos
- Excluir: limpando um conjunto ao remover todos os seus elementos
Operações Comuns em Conjuntos Explicadas com Código Python
Conjuntos em Python permitem realizar operações básicas da teoria dos conjuntos. Vamos explorar essas operações nesta seção.
#1. União de Conjuntos em Python
Na teoria dos conjuntos, a união de dois conjuntos resulta em um conjunto que contém todos os elementos presentes em pelo menos um dos conjuntos. Dados dois conjuntos A e B, a união contém elementos que estão apenas em A, apenas em B, ou em ambos.
Para calcular a união de conjuntos, use o operador `|` ou o método `.union()`, cuja sintaxe é `setA.union(setB)`.
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8, 9}
A união de conjuntos é comutativa. AUB é o mesmo que BUA. Vamos verificar isso ao inverter a ordem de `setA` e `setB` na chamada do método `.union()`.
setB.union(setA)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8, 9}
#2. Interseção de Conjuntos em Python
Outra operação importante é a interseção de dois conjuntos A e B. Esta operação retorna um conjunto com os elementos que estão presentes em ambos, A e B.
Para calcular a interseção, você pode usar o operador `&` ou o método `.intersection()`, como no código a seguir.
print(setA & setB)
# Saída
{9}
setA.intersection(setB)
# Saída
{9}
Neste exemplo, apenas o elemento 9 está presente em `setA` e `setB`. Portanto, o conjunto interseção contém apenas esse elemento.
Assim como a união de conjuntos, a interseção também é uma operação comutativa.
setB.intersection(setA)
# Saída
{9}
#3. Diferença de Conjuntos em Python
Dados dois conjuntos, união e interseção nos ajudam a encontrar elementos presentes em pelo menos um ou em ambos os conjuntos, respectivamente. A operação de diferença, por outro lado, nos permite descobrir os elementos que estão em um conjunto mas não em outro.
– `setA.difference(setB)` retorna o conjunto de elementos que estão em `setA` mas não em `setB`.
– `setB.difference(setA)` retorna o conjunto de elementos que estão em `setB` mas não em `setA`.
print(setA - setB)
print(setB - setA)
# Saída
{1, 3, 5, 7}
{8, 2, 4, 6}
Claramente, AB não é o mesmo que BA, então a operação de diferença de conjuntos não é comutativa.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}
#4. Diferença Simétrica de Conjuntos em Python
Enquanto a interseção nos dá os elementos presentes em ambos os conjuntos, a diferença simétrica retorna os elementos que estão em apenas um dos conjuntos.
Considere o seguinte exemplo.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}
Para calcular a diferença simétrica, utilize o operador `^` ou o método `.symmetric_difference()`.
print(setA ^ setB)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8}
Os elementos 10 e 12 estão presentes tanto em `setA` quanto em `setB`, portanto não aparecem no conjunto resultado da diferença simétrica.
setA.symmetric_difference(setB)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8}
A diferença simétrica é comutativa, pois coleta elementos que aparecem em exatamente um dos conjuntos, independentemente da ordem em que são considerados.
setB.symmetric_difference(setA)
# Saída
{1, 2, 3, 4, 5, 6, 7, 8}
#5. Subconjuntos e Superconjuntos em Python
Na teoria dos conjuntos, subconjuntos e superconjuntos nos ajudam a entender a relação entre dois conjuntos.
Dados dois conjuntos A e B, o conjunto B é um subconjunto de A se todos os elementos de B estiverem também presentes em A, e A é o superconjunto de B.
Considere dois conjuntos: `linguagens` e `linguagens_estendidas`.
linguagens = {'Python', 'JavaScript','C','C++'}
linguagens_estendidas = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}
Em Python, o método `.issubset()` verifica se um conjunto é subconjunto de outro.
`setA.issubset(setB)` retorna `True` se `setA` for subconjunto de `setB`. Caso contrário, retorna `False`.
Neste exemplo, `linguagens` é um subconjunto de `linguagens_estendidas`.
linguagens.issubset(linguagens_estendidas) # Saída True
De forma similar, use o método `.issuperset()` para verificar se um conjunto é um superconjunto de outro.
`setA.issuperset(setB)` retorna `True` se `setA` for superconjunto de `setB`, e `False` caso contrário.
linguagens_estendidas.issuperset(linguagens) # Saída True
Como `linguagens_estendidas` é um superconjunto de `linguagens`, `linguagens_estendidas.issuperset(linguagens)` retorna `True`.
Conclusão
Espero que este guia tenha ajudado você a entender o funcionamento dos conjuntos em Python, seus métodos para operações CRUD e as operações comuns da teoria dos conjuntos. Como próximo passo, você pode tentar aplicá-los em seus projetos com Python.
Consulte outros guias detalhados sobre Python para expandir ainda mais seus conhecimentos. Bons estudos!