Sets – Conjuntos em Python

Sets – Conjuntos em Python

Em Python, um Set (conjunto) é uma coleção não-ordenada de valores únicos, empregada para armazenar múltiplos itens em um objeto.

Algumas das principais características dos conjuntos incluem:

  • Armazena apenas itens não-duplicados (únicos)
  • Suporta operações matemáticas sobre conjuntos (união, intersecção, etc)
  • Não é possível modificar os itens existentes, mas podemos adicionar novos elementos (sets são mutáveis).
  • Suporta elementos de qualquer tipo, não-ordenados e não-indexados.
  • Podem conter apenas objetos imutáveis, como strings, ints, floats e tuplas de objetos também imutáveis.
  • São escritos com chaves.

Os sets são iteráveis (podemos acessar seus elementos um a um), e não são considerados sequências como as tuplas e as listas. Eles também não suportam indexação e slicing. Assim, os itens de um set são retornados em uma ordem diferente cada vez que acessamos o conjunto todo.

Como criar um conjunto em Python

Criamos um conjunto atribuindo seus elementos, separados por vírgulas e entre chaves, a uma variável.

planeta_anao = {'Plutão','Ceres','Eris','Haumea','Makemake'}
print(planeta_anao)

Eliminação duplicada

Se tentarmos criar um conjunto contendo valores duplicados, essas cópias são eliminadas automaticamente. Um set não possui valores repetidos.

Tamanho de um set

Podemos descobrir o tamanho de um conjunto (número de elementos) com a função len():

qtde_planetas = len(planeta_anao)
print(qtde_planetas)

Associação em um set

É possível verificar se um conjunto possui um valor em particular com os operadores in e not in:

print('Ceres' in planeta_anao)
print('Lua' in planeta_anao)
print('Eris' not in planeta_anao)

Iteração em um set

Como os sets são iteráveis, podemos processar cada elemento com um laço for:

for astro in planeta_anao:
    print(astro.upper(), end=' ')

Criar conjunto com função set()

Podemos criar um conjunto a partir de uma outra coleção de valores usando a função interna set():

astros = ['Lua', 'Vênus', 'Sirius', 'Marte', 'Lua']
print(astros, end=' ')
astrosSet = set(astros)
print(astrosSet, end=' ')

Note que o valor duplicado ‘Lua’, presente na lista, não aparece duplicado no conjunto criado.
Um conjunto vazio pode ser criado simplesmente executando set(), sem parâmetros.

Comparação de conjuntos

Podemos comparar dois conjuntos usando operadores de comparação comuns.
Verificamos se dois conjuntos são iguais ou diferentes com os operadores == e !=

planetas1 = {'Terra', 'Vênus', 'Mercúrio', 'Marte'}
planetas2 = {'Terra', 'Vênus', 'Mercúrio', 'Marte', 'Saturno'}
print(planetas1 == planetas2)
print(planetas1 != planetas2)

Com o operador < verificamos se o conjunto à esquerda é um subconjunto próprio do conjunto à direita do operador.
Ou seja, se todos os elementos à esquerda estão no conjunto da direita, e os conjuntos não são iguais:

planetas1 = {'Terra', 'Vênus', 'Mercúrio'}
planetas2 = {'Terra', 'Mercúrio', 'Vênus', 'Saturno', 'Marte'}
print(planetas1 < planetas2)

O operador > inverte a ordem de comparação, ou seja, verifica se o conjunto à direita é um subconjunto próprio do conjunto à esquerda.

Já o operador <= verifica se o conjunto à esquerda é um subconjunto impróprio do conjunto à direita do operador.
Ou seja, verifica se todos os elementos à esquerda estão no conjunto da direita, e os conjuntos são iguais:

planetas1 = {'Terra', 'Vênus', 'Mercúrio'}
planetas2 = {'Terra', 'Mercúrio', 'Vênus', 'Saturno', 'Marte'}
print(planetas1 <= planetas2)

Já o operador >= inverte a ordem de comparação, ou seja, verifica se o conjunto à direita é um subconjunto impróprio do conjunto à esquerda (ou seja, se o conjunto à esquerda é um superconjunto do conjunto à direita).

União de conjuntos

A união de dois conjuntos é um conjunto contendo todos os elementos únicos de cada conjunto.
Para tal empregamos o operador | ou o método union().

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
print(planetas1 | planetas2)
print(planetas1.union(planetas2))

Intersecção de conjuntos

A intersecção de dois conjuntos é um conjunto contendo apenas os elementos em comum que os conjuntos possuem.
Para tal empregamos o operador & ou o método intersection().

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
print(planetas1 & planetas2)
print(planetas1.intersection(planetas2))

Diferença de conjuntos

A diferença entre dois conjuntos é um conjunto contendo os elementos do conjunto à esquerda que não estão no conjunto à direita do operador.
Para tal empregamos o operador ou o método difference().

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
print(planetas1 - planetas2)
print(planetas1.difference(planetas2))

Diferença simétrica de conjuntos

A diferença simétrica entre dois conjuntos é um conjunto contendo os elementos de ambos os conjuntos que não são comuns um com o outro. Ou seja, apenas os itens não-repetidos.
Para tal empregamos o operador ^ ou o método symmetric_difference().

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
print(planetas1 ^ planetas2)
print(planetas1.symmetric_difference(planetas2))

Conjuntos disjuntos

Dois conjuntos são disjuntos se eles não possuírem nenhum elemento em comum.
Para verificar se dois conjuntos são disjuntos empregamos o método isdisjoint().

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
planetas3 = {'Júpiter', 'Urano', 'Saturno'}
print(planetas1.isdisjoint(planetas2))
print(planetas1.isdisjoint(planetas3))

Atribuição de União

Operação de união aumentada com o operador |= ou com o método update(). Realiza uma operação de união, porém modificando o operando à esquerda.

planetas1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
planetas2 = {'Terra', 'Júpiter', 'Urano', 'Saturno', 'Marte'}
planetas1 |= planetas2
# planetas1.update(planetas2)  # descomente para testar este também
print(planetas1)

Outros métodos de atribuição especial incluem:

  • Intersecção aumentada: operador &= ou método intersection_update()
  • Diferença aumentada: operador -= ou método difference_update()
  • Diferença simétrica aumentada: operador ^= ou método symmetric_difference_update()

Cópia de conjuntos

Podemos criar um novo conjunto contendo os mesmos elementos de outro conjunto com o método copy()

p1 = {'Vênus', 'Mercúrio', 'Terra', 'Netuno', 'Marte'}
p2 = p1.copy()
print('Conjunto 1:', p1)
print('Conjunto 2:', p2)

Não faça atribuição direta de conjuntos para criar cópias (c1 = c2), pois isso na verdade cria duas referências para um mesmo conjunto – se um for modificado, a modificação se reflete no outro.

Adicionar e remover elementos em conjuntos

Podemos adicionar ou remover elementos em um conjunto com os métodos add(), remove() e discard().

planetas = {'Mercúrio', 'Vênus', 'Terra', 'Marte'}
planetas.add('Júpiter')
planetas.add('Marte') # elemento já existe, não é adicionado.
print(planetas, end=' ')
planetas.remove('Terra') # causa erro se o elemento não estiver no conjunto
print(planetas, end=' ')
planetas.discard('Terra')
print(planetas, end=' ')

Podemos remover um elemento arbitrário de um conjunto com o método pop(), que também retorna o elemento.

planetas = {'Mercúrio', 'Vênus', 'Terra', 'Marte'}
print(planetas, end=' ')
planetas.pop() # remove um elemento arbitrário.
print(planetas, end=' ')

Atenção: Como os conjuntos não são ordenados, não é possível saber qual elemento será removido e retornado do conjunto com o método pop() e, portanto, o elemento a ser removido é uma “surpresa”.

O método clear() limpa o conjunto todo (o esvazia):

planetas.clear()
print('Planetas:', planetas)

Frozensets

Os sets são mutáveis (podem ser alterados), mas seus elementos em si são imutáveis. Assim, um set não pode conter outros sets como elementos.

Um Frozenset é um conjunto imutável (não pode ser modificado após a criação; frozen significa “congelado“), e pode conter outros frozensets como elementos.

São úteis como chaves em um dicionário ou como elementos de um outro set.

planetas = ['Terra', 'Vênus', 'Urano', 'Marte']
planetas = frozenset(planetas)
estrelas = ['Sirius', 'Rigel', 'Canopus', 'Vega']
estrelas = frozenset(estrelas)
astros = set([planetas, estrelas, 'Sol', 'Halley'])
for astro in astros:
    print(astro)

É isso aí! Na dúvida ainda? Então assista a uma vídeo da Bóson Treinamentos sobre o assunto Sets em Python para uma explicação diferente:

 

Sobre Fábio dos Reis (1364 Artigos)
Fábio dos Reis trabalha com tecnologias variadas há mais de 25 anos, tendo atuado nos campos de Eletrônica, Telecomunicações, Programação de Computadores e Redes de Dados. É um entusiasta de Unix, Linux e Open Source em geral, adora Eletrônica e Música, e estuda idiomas, além de ministrar cursos e palestras sobre diversas tecnologias em São Paulo e outras cidades do Brasil.
Contato: Website

2 Comentários em Sets – Conjuntos em Python

  1. Só vi aqui agradecer pelo seu esforço e dedicação, sou estudante de TI, e desde de muito tempo fiquei sabendo sobre seu canal e conteúdos, coisas que aprendia no técnico ou faculdade estavam disponíveis em seu canal e site. Fico agradecido demais Bóson, por estar dedicando tempo e energia para ensinar pessoas com conteúdos riquíssimos. Parabéns e obrigado!

Escreva um comentário

Seu e-mail não será divulgado


*