A diferença entre conjuntos e dicionários é que conjuntos possuem apenas valores, enquanto dicionários têm chaves. Dicionários são pares chave-valor.

Portanto, para criar um conjunto vazio, não se pode usar chaves {} pois isso criará um dicionário vazio. Para criar um conjunto vazio, utilize set().

Criando Conjuntos

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando um conjunto
conjunto_vazio = set()
conjunto_numeros = {11, 22, 33, 44, 55, 55}
print(conjunto_numeros)
# Resultado: {33, 11, 44, 22, 55}

Convertendo para Conjuntos

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Convertendo para conjuntos
lista_numeros = [11, 22, 33, 44, 55]
tupla_numeros = (11, 22, 33, 44, 55)
string_caracteres = "123456789"

# Convertendo lista para conjunto
conjunto_lista = set(lista_numeros)
print(conjunto_lista)
# Convertendo tupla para conjunto
conjunto_tupla = set(tupla_numeros)
print(conjunto_tupla)
# Convertendo string para conjunto
conjunto_string = set(string_caracteres)
print(conjunto_string)
# Resultados:
#{33, 11, 44, 22, 55}
#{33, 11, 44, 22, 55}
#{'7', '5', '1', '9', '4', '2', '8', '6', '3'}

Métodos de Conjuntos

add(self, elemento)

Adiciona um elemento ao conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando um conjunto
numeros = {11, 22, 33, 44}
# Adicionando elemento ao conjunto
numeros.add(55)
print(numeros)
# Resultado: {33, 11, 44, 22, 55}

clear(self)

Remove todos os elementos do conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando um conjunto
numeros = {11, 22, 33, 44}
# Removendo todos os elementos
numeros.clear()
print(numeros)
# Resultado: set() (conjunto vazio)

difference(self, outro_conjunto)

Retorna elementos que estão no conjunto atual mas não no outro conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {11, 22, 33, 44}
conjunto_b = {11, 55, 88, 44}
# Encontrando elementos em A que não estão em B
diferenca = conjunto_a.difference(conjunto_b)
print(diferenca)
# Resultado: {33, 22}

difference_update(self, outro_conjunto)

Remove do conjunto atual os elementos que também estão no outro conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {11, 22, 33, 44, 999}
conjunto_b = {11, 55, 88, 44}
# Removendo de A elementos que estão em B
conjunto_a.difference_update(conjunto_b)
print(conjunto_a)
# Resultado: {33, 22, 999}

discard(self, elemento)

Remove um elemento específico do conjunto. Se o elemento não existir, não gera erro.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando um conjunto
numeros = {11, 22, 33, 44, 999}
# Removendo elemento específico
numeros.discard(999)
print(numeros)
# Resultado: {33, 11, 44, 22}

intersection(self, outro_conjunto)

Retorna a interseção entre dois conjuntos (elementos presentes em ambos).

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {66, 22, 33, 44, 99}
conjunto_b = {44, 55, 66, 77, 33}
# Encontrando elementos comuns
interseccao = conjunto_a.intersection(conjunto_b)
print(interseccao)
# Resultado: {33, 66, 44}

intersection_update(self, outro_conjunto)

Atualiza o conjunto atual com a interseção entre ele e outro conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {66, 22, 33, 44, 99}
conjunto_b = {44, 55, 66, 77, 33}
# Atualizando A com elementos comuns
conjunto_a.intersection_update(conjunto_b)
print(conjunto_a)
# Resultado: {33, 66, 44}

isdisjoint(self, outro_conjunto)

Verifica se dois conjuntos são disjuntos (não têm elementos em comum).

Retorna True se não houver elementos em comum, False caso contrário.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {66, 22, 33, 44, 99}
conjunto_b = {44, 55, 66, 77, 33}
# Verificando se há elementos em comum
tem_interseccao = conjunto_a.isdisjoint(conjunto_b)
print(tem_interseccao)
# Resultado: False (indicando que há interseção)

issubset(self, outro_conjunto)

Verifica se o conjunto atual é subconjunto do outro conjunto.

Retorna True se for subconjunto, False caso contrário.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {11, 22, 33, 44}
conjunto_b = {11, 22}
# Verificando relações de subconjunto
e_subconjunto_a_b = conjunto_a.issubset(conjunto_b)
e_subconjunto_b_a = conjunto_b.issubset(conjunto_a)
print(e_subconjunto_a_b)
print(e_subconjunto_b_a)
# Resultados:
#False (A não é subconjunto de B)
#True (B é subconjunto de A)

issuperset(self, outro_conjunto)

Verifica se o conjunto atual é superconjunto do outro conjunto.

Retorna True se for superconjunto, False caso contrário.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Criando dois conjuntos
conjunto_a = {11, 22, 33, 44}
conjunto_b = {11, 22}
# Verificando relações de superconjunto
e_superconjunto_a_b = conjunto_a.issuperset(conjunto_b)
e_superconjunto_b_a = conjunto_b.issuperset(conjunto_a)
print(e_superconjunto_a_b)
print(e_superconjunto_b_a)
# Resultados:
#True (A é superconjunto de B)
#False (B não é superconjunto de A)

pop(self)

Remove e retorna um elemento aleatório do conjunto.

Como conjuntos são desordenados, o elemento removido pode não ser o "primeiro" na ordem de visualização.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
numeros = {44, 55, 66, 77, 88}
# Exibindo o conjunto
print(numeros)
# Removendo um elemento aleatório
elemento_removido = numeros.pop()
# Exibindo o elemento removido
print(elemento_removido)
# Exibindo o conjunto após remoção
print(numeros)
# Resultados possíveis:
#{88, 66, 44, 77, 55}
#88
#{66, 44, 77, 55}

remove(self, elemento)

Remove um elemento específico do conjunto. Se o elemento não existir, gera um erro.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
numeros = {44, 55, 66, 77, 88}
# Exibindo o conjunto
print(numeros)
# Removendo elemento específico
numeros.remove(44)
# Exibindo o conjunto após remoção
print(numeros)
# Resultados:
#{88, 66, 44, 77, 55}
#{88, 66, 77, 55}

symmetric_difference(self, outro_conjunto)

Retorna a diferença simétrica entre dois conjuntos (elementos que estão em um mas não em ambos).

#!/usr/bin/env python
# -*- coding:utf-8 -*-
conjunto_a = {44, 55, 66, 77, 88}
conjunto_b = {44, 55, 11, 22, 33}
# Encontrando diferença simétrica
diferenca_simetrica = conjunto_a.symmetric_difference(conjunto_b)
print(diferenca_simetrica)
# Resultado: {33, 66, 11, 77, 22, 88}

symmetric_difference_update(self, outro_conjunto)

Atualiza o conjunto atual com a diferença simétrica entre ele e outro conjunto.

#!/usr/bin/env python
# -*- coding:utf-8 -*-
conjunto_a = {44, 55, 66, 77, 88}
conjunto_b = {44, 55, 11, 22, 33}
# Atualizando A com diferença simétrica
conjunto_a.symmetric_difference_update(conjunto_b)
print(conjunto_a)
# Resultado: {33, 66, 11, 77, 22, 88}

union(self, outro_conjunto)

Retorna a união entre dois conjuntos (todos os elementos de ambos, sem duplicatas).

#!/usr/bin/env python
# -*- coding:utf-8 -*-
conjunto_a = {44, 55, 66, 77, 88}
conjunto_b = {44, 55, 11, 22, 33}
# Unindo conjuntos
uniao = conjunto_a.union(conjunto_b)
print(uniao)
# Resultado: {33, 66, 11, 44, 77, 22, 55, 88}

update(self, outro_conjunto)

Atualiza o conjunto atual com elementos do outro conjunto (união in-place).

#!/usr/bin/env python
# -*- coding:utf-8 -*-
conjunto_a = {44, 55, 66, 77, 88}
conjunto_b = {44, 55, 11, 22, 33}
# Atualizando A com elementos de B
conjunto_a.update(conjunto_b)
print(conjunto_a)
# Resultado: {33, 66, 11, 44, 77, 22, 55, 88}