Conjuntos (Sets) em Python

Conjuntos (Sets) em Python#

Vamos agora nos dedicar a compreender Conjuntos em Python. Vamos cobrir o conceito, suas características e aplicações práticas.

Objetivos de Aprendizagem#

  • Criar conjuntos usando chaves {} e a função set()

  • Compreender as restrições quanto aos tipos de dados permitidos dentro de um conjunto (imutabilidade).

  • Demonstrar proficiência em realizar operações comuns com conjuntos, como união, interseção e diferença.

Conceitos Fundamentais#

Em matemática, um conjunto é uma coleção não ordenada de elementos únicos. Em Python, os conjuntos são implementados como objetos do tipo set. Eles são usados para armazenar coleções de itens distintos e oferecem operações eficientes para testes de pertinência (membership testing), remoção de duplicatas e outras operações matemáticas de conjuntos, como união, interseção e diferença.

Sintaxe: Existem duas maneiras principais de criar um conjunto em Python:

  • Usando chaves {}: Você pode criar um conjunto diretamente usando chaves, mas lembre-se que a sintaxe com chaves também é usada para dicionários!

meu_conjunto = {1, 2, 3, 4, 5}
print(meu_conjunto)  # Saída: {1, 2, 3, 4, 5}

{1, 2, 3, 4, 5}

  • Usando a função set(): A função set() pode ser usada para converter uma lista ou qualquer outro iterável em um conjunto. Isso é particularmente útil para remover duplicatas de uma lista.

lista_com_duplicatas = [1, 2, 2, 3, 4, 4, 5]
conjunto_sem_duplicatas = set(lista_com_duplicatas)
print(conjunto_sem_duplicatas)  # Saída: {1, 2, 3, 4, 5}

{1, 2, 3, 4, 5}

Importante: Conjuntos não podem conter elementos mutáveis como listas ou outros conjuntos. Eles só podem conter tipos de dados hashable, como números, strings e tuplas.

grupos_de_cores = {["rosa", "amarelo"], ["verde", "branco"]}

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[3], line 1
----> 1 grupos_de_cores = {["rosa", "amarelo"], ["verde", "branco"]}

TypeError: unhashable type: 'list'

Características dos Conjuntos#

  • Não Ordenados: Os elementos em um conjunto não mantém a ordem na qual eles foram adicionados ao conjunto.

  • Únicos: Um conjunto não pode conter elementos duplicados. Se você tentar adicionar um elemento que já existe, ele será ignorado.

  • Mutáveis: Um conjunto é mutável – você pode adicionar e remover elementos após a criação.

meu_conjunto = {2, 2, 1, 4, 5}
print(meu_conjunto)

{1, 2, 4, 5}

Operações Básicas#

Python oferece uma variedade de operações para manipular conjuntos:

Adicionando Elementos: add(elemento) adiciona um elemento ao conjunto.

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

{1, 2, 3, 4}

Removendo Elementos: remove(elemento) remove um elemento específico do conjunto.

meu_conjunto = {1, 2, 3}
meu_conjunto.remove(2)
print(meu_conjunto)

{1, 3}
{1, 3}

Observação: Se o elemento não existir, remove(elemento) produz um erro.

meu_conjunto = {1, 3}
meu_conjunto.remove(2)
print(meu_conjunto)

---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
Cell In[16], line 2
      1 meu_conjunto = {1, 3}
----> 2 meu_conjunto.remove(2)
      3 print(meu_conjunto)

KeyError: 2

Para evitar essa situação, use discard(elemento): remove um elemento se ele estiver presente, mas não levanta um erro caso contrário.

meu_conjunto = {1, 3}
meu_conjunto.discard(2) # Não levanta erro porque 2 não está no conjunto
print(meu_conjunto)

{1, 3}

União: | ou union() retorna um novo conjunto contendo todos os elementos de ambos os conjuntos.

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}
uniao = conjunto1 | conjunto2  # Ou: uniao = conjunto1.union(conjunto2)
print(uniao)  # Saída: {1, 2, 3, 4, 5}

{1, 2, 3, 4, 5}

Interseção: & ou intersection() retorna um novo conjunto contendo apenas os elementos que estão presentes em ambos os conjuntos.

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}
intersecao = conjunto1 & conjunto2  # Ou: intersecao = conjunto1.intersection(conjunto2)
print(intersecao)  # Saída: {3}

{3}

Diferença: - ou difference() retorna um novo conjunto contendo os elementos que estão presentes no primeiro conjunto, mas não no segundo.

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}
diferenca = conjunto1 - conjunto2  # Ou: diferenca = conjunto1.difference(conjunto2)
print(diferenca)  # Saída: {1, 2}

{1, 2}

Teste de Pertinência: in verifica se um elemento está presente no conjunto.

meu_conjunto = {1, 2, 3}
print(2 in meu_conjunto)  # Saída: True
print(4 in meu_conjunto)  # Saída: False

True
False

Percorrendo um Tuplas em um Loop#

Vamos criar uma nova tupla e percorrê-la utilizando um loop for:

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

for x in meu_conjunto:
    print(x)

1
2
3
4
5
6

Funções built-in do Python#

# Criando um conjunto para os exemplos
meu_conjunto = {10, 5, 20, 15, 5, 25}  # Note a duplicidade do '5' - será removida.

Exemplo 1: len() - Obtendo o número de elementos em uma tupla.

tamanho = len(meu_conjunto)
print(f"Tamanho do conjunto: {tamanho}")

Tamanho do conjunto: 5

Exemplo 2: max() - Encontrando o Maior Elemento

maior_elemento = max(meu_conjunto)
print(f"Maior elemento: {maior_elemento}")

Maior elemento: 25

Exemplo 3: min() - Encontrando o Menor Elemento

menor_elemento = min(meu_conjunto)
print(f"Menor elemento: {menor_elemento}")

Menor elemento: 5

Exemplo 4: sum() - Somando os Elementos (para Conjuntos Numéricos)

soma = sum(meu_conjunto)
print(f"Soma dos elementos: {soma}")

Soma dos elementos: 75

Exercícios Teóricos#

Para testar a compreensão conceitual de vocês sobre conjuntos em Python, preparei cinco questões teóricas. Pensem com calma e justifiquem suas respostas – o raciocínio é tão importante quanto a resposta correta!

  1. Explique a diferença fundamental entre uma lista e um conjunto em Python, destacando as principais características que os distinguem. (Pensem na ordem dos elementos, duplicatas e como isso afeta o uso de cada estrutura.)

  2. Descreva a importância da operação de interseção entre dois conjuntos. Em qual cenário prático essa operação seria particularmente útil? (Pensem em exemplos do mundo real onde você precisa encontrar elementos comuns.)

Exercícios para Praticar#

  1. Remova as duplicatas de uma lista usando um conjunto.

  2. Encontre os elementos comuns entre dois conjuntos.

  3. Determine a diferença entre dois conjuntos.

  4. Crie um programa que utilize conjuntos para verificar se duas listas contêm os mesmos elementos, independentemente da ordem.

  5. Considere o seguinte código Python:

    conjunto_a = {1, 2, 3, 4, 5}
conjunto_b = {3, 5, 6, 7, 8}
conjunto_c = conjunto_a.union(conjunto_b)
conjunto_d = conjunto_a.intersection(conjunto_b)
conjunto_e = conjunto_a - conjunto_b

print(f"Conjunto A: {conjunto_a}")
print(f"Conjunto B: {conjunto_b}")
print(f"Conjunto C (A U B): {conjunto_c}")
print(f"Conjunto D (A ∩ B): {conjunto_d}")
print(f"Conjunto E (A - B): {conjunto_e}")

    Responda às seguintes perguntas:

    1. Qual é o valor do conjunto_c após a execução do código? Explique como ele foi obtido.

    2. Qual é o valor do conjunto_d após a execução do código? Explique como ele foi obtido.

    3. Qual é o valor do conjunto_e após a execução do código? Explique como ele foi obtido.

    4. Se você substituísse conjunto_a por uma lista em vez de um conjunto, qual erro ocorreria ao tentar executar a linha conjunto_c = conjunto_a.union(conjunto_b)? Justifique sua resposta.

    5. Suponha que você quisesse adicionar o número 9 ao conjunto_a. Escreva uma única linha de código para realizar essa operação.

Conclusão#

Exploramos um tipo de dado fundamental em Python: os conjuntos. Vimos como eles se diferenciam das listas e tuplas, principalmente pela garantia de elementos únicos. Dominar conjuntos é crucial para tarefas como remoção de duplicatas, operações matemáticas de conjuntos (união, interseção, diferença) e otimização de testes de pertinência.

O que aprendemos hoje?#

  • Definimos e criamos conjuntos usando chaves {} e a função set().

  • Aplicamos operações como união, interseção e diferença para manipular conjuntos.

  • Utilizamos o operador in para verificar a pertinência de elementos em um conjunto.

  • Exploramos funções built-in como len(), max(), min() e sorted() aplicadas a conjuntos.

Próximos Passos#

  • Prática: Resolva os exercícios propostos no material da aula para solidificar o entendimento dos conceitos.

  • Exploração: Pesquise sobre as aplicações de conjuntos em áreas como análise de dados, algoritmos e otimização.

Contents