Conjuntos são uma das estruturas de dados internas do Python. Uma das características principais dos conjuntos é que eles não armazenam valores duplicados. Se você tentar adicionar um valor duplicado a um conjunto, apenas um deles será armazenado. Conjuntos são mutáveis e não ordenados, o que significa que seus elementos não são armazenados em nenhuma ordem específica, então você não pode usar índices ou chaves para acessá-los. Eles só podem conter valores de tipos de dados imutáveis como números, strings e tuplas. E eles suportam operações matemáticas de conjuntos, incluindo união, interseção, diferença e diferença simétrica. Para definir um conjunto, você só precisa escrever seus elementos dentro de chaves e separá-los com vírgulas. Este é um exemplo de um conjunto de números:

my_set = {1, 2, 3, 4, 5}

Uma peculiaridade de trabalhar com conjuntos é que, se você precisar definir um conjunto vazio, deve usar a função set(). Se você apenas escrever chaves vazias, como {}, o Python criará automaticamente um dicionário.

set() # Set
{}    # Dictionary

Você pode adicionar um elemento a um conjunto com o método .add(), e passar o novo elemento como argumento:

my_set.add(6)

No nosso exemplo, o novo conjunto seria:

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

Se você tentar adicionar um elemento que já está no conjunto, apenas um será mantido. Neste caso, já temos o número 5 no conjunto:

my_set.add(5)

Então o conjunto não vai mudar:

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

Para remover um elemento do conjunto, você tem duas opções. Você pode usar o método .remove() ou o método .discard(), e passar o elemento que deseja remover como argumento. O método .remove() lançará um KeyError se o elemento não for encontrado, enquanto o método .discard() não lançará:

my_set.remove(4)
my_set.discard(4)

O método .clear() remove todos os elementos do conjunto:

my_set.clear()

Conjuntos Python também possuem métodos poderosos que realizam operações matemáticas comuns de conjuntos. Os métodos .issubset() e .issuperset() verificam se um conjunto é um subconjunto ou superconjunto de outro conjunto, respectivamente. Aqui, estamos verificando se your_set é um subconjunto de my_set, o que é False porque nem todos os elementos de your_set estão em my_set. Também estamos verificando se my_set é um superconjunto de your_set. Isto também é False porque my_set não possui todos os elementos de your_set:

my_set = {1, 2, 3, 4, 5}
your_set = {2, 3, 4, 6}

print(your_set.issubset(my_set)) # False
print(my_set.issuperset(your_set)) # False

O método .isdisjoint() verifica se dois conjuntos são disjuntos, o que significa que eles não têm nenhum elemento em comum. Neste caso, isso é False porque my_set e your_set têm elementos em comum – 2, 3 e 4:

print(my_set.isdisjoint(your_set)) # False

O operador de união | retorna um novo conjunto com todos os elementos de ambos os conjuntos:

my_set | your_set # {1, 2, 3, 4, 5, 6}

O operador de interseção & retorna um novo conjunto com apenas os elementos que os conjuntos têm em comum:

my_set & your_set # {2, 3, 4}

O operador de diferença - retorna um novo conjunto com os elementos do primeiro conjunto que não estão nos outros conjuntos. Neste exemplo, os números 1 e 5 estão em my_set mas NÃO em your_set:

my_set - your_set # {1, 5}

The symmetric difference operator ^ returns a new set with the elements that are either in the first or the second set, but not both. Neste caso, 1 e 5 estão em my_set mas não em your_set, então eles são incluídos. E o número 6 está em your_set mas não em my_set, então ele também está incluído:

my_set ^ your_set # {1, 5, 6}

Cada um desses operadores também possui seu operador de atribuição composto correspondente se você adicionar o sinal de igual ao lado dele. Esses operadores atribuem automaticamente o conjunto resultante ao primeiro conjunto na expressão:

|= &= -= ^=

Por exemplo, o operador -= encontra a diferença entre os conjuntos e atualiza o primeiro conjunto com esse resultado:

my_set -= your_set

Depois disso, my_set será atualizado para {1, 5}:

print(my_set) # {1, 5}

Você pode verificar se um elemento está em um conjunto ou não com o operador in. Aqui, estamos verificando se 5 está em my_set. O resultado será um valor booleano True ou False:

print(5 in my_set)

E esses são os fundamentos dos conjuntos. Eles são muito úteis quando você não precisa armazenar os valores em uma ordem específica e quando você só precisa armazenar valores únicos.