Obtendo Subconjunto

4.1 Obtendo Subconjunto pela regra

Um subconjunto é um conjunto cujos elementos pertencem a outro conjunto maior. Em Python, existem vários métodos e operadores embutidos para trabalhar com subconjuntos. Abaixo, eu vou contar como obter subconjuntos, como verificar se um conjunto é subconjunto de outro, e como usar esse conhecimento em vários cenários.

Usando o loop for

Você pode criar um conjunto vazio e adicionar elementos que satisfaçam uma condição usando um loop for.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set()
            
for x in my_set:
    if x % 2 == 0:
        even_set.add(x)
            
print(even_set)  # Saída: {2, 4, 6, 8, 10}
        

Este é o jeito mais simples e óbvio de criar um subconjunto. Mas há outras maneiras mais compactas.

Usando a função filter()

A função filter() aplica uma função a cada elemento e retorna apenas os elementos para os quais a função retornou True. O resultado precisa ser convertido de novo em conjunto.

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = set(filter(lambda x: x % 2 == 0, my_set))
print(even_set)  # Saída: {2, 4, 6, 8, 10}
        

Dentro da função filter() usamos uma expressão lambda – é um jeito curto de definir uma função ou regra para o filtro. Vou falar sobre lambdas em poucas aulas.

4.2 Usando Geradores de Conjuntos

Lembra do List Comprehension? Quando usávamos colchetes para criar rapidamente uma lista e seus elementos? Essa ferramenta sintática tinha esta forma:

[expressão for variável in sequência]

Onde:

• variável — identificador de alguma variável,
• sequência — sequência de valores que a variável pode assumir (pode ser uma lista, string ou objeto criado com a função range),
• expressão — alguma expressão, geralmente dependente da variável usada no gerador, que será utilizada para preencher os elementos da lista.

Para conjuntos há uma função semelhante, só que você usa chaves:

{expressão for variável in sequência}

Geradores de conjuntos permitem criar novos conjuntos de forma simples e direta baseados em conjuntos existentes, aplicando condições de filtro.

Assim você pode selecionar apenas os elementos pares de um conjunto:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
even_set = {x for x in my_set if x % 2 == 0} 
print(even_set)  # Saída: {2, 4, 6, 8, 10} 

E assim apenas strings:

my_set = {1, 2, 3, 4, 5, 6, 7, 8, 9, "apple", "banana"}
even_set = {x for x in my_set if type(x) == str}
print(even_set)  # Saída: {"apple", "banana"}

4.3 Verificando a presença de um elemento

Uma das operações básicas que você pode fazer com conjuntos é verificar se um elemento está em um conjunto. Em Python, existem várias maneiras de fazer isso. Vamos ver diferentes métodos de verificar se um elemento está presente em um conjunto.

Usando o operador in

O jeito mais comum e conveniente de verificar a presença de um elemento em um conjunto é usar o operador in. Este método retorna True se o elemento está no conjunto e False se não estiver.

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

Usando o operador not in

O operador not in é o oposto de in e é usado para verificar se um elemento não está em um conjunto. Ele retorna True se o elemento não está no conjunto e False caso contrário.

my_set = {1, 2, 3, 4, 5}
print(6 not in my_set)  # Saída: True
print(3 not in my_set)  # Saída: False

Usando loops

Embora usar loops para verificar a presença de um elemento em um conjunto não seja o método mais eficiente, pode ser útil em situações onde você está lidando com estruturas de dados mais complexas ou realizando operações adicionais.

my_set = {1, 2, 3, 4, 5}
element = 3
found = False
            
for item in my_set:
    if item == element:
        found = True
        break
            
print(found)  # Saída: True
        

4.4 Verificação de Subconjuntos

Python oferece o operador <= e o método issubset() para verificar se um conjunto é subconjunto de outro.

Usando o operador <=

O operador <= permite verificar facilmente se um conjunto é subconjunto de outro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a <= set_b)  # Saída: True
print(set_b <= set_a)  # Saída: False
            
        

Usando o método issubset()

O método issubset() faz a mesma coisa que o operador <= e retorna True se todos os elementos de um conjunto estão contidos em outro.

set_a = {1, 2, 3}
set_b = {1, 2, 3, 4, 5}
            
print(set_a.issubset(set_b))  # Saída: True
print(set_b.issubset(set_a))  # Saída: False
        

Verificação de Superconjunto

Assim como nos subconjuntos, você pode verificar se um conjunto é superconjunto de outro usando o operador >= e o método issuperset().

Usando o operador >=

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a >= set_b)  # Saída: True
print(set_b >= set_a)  # Saída: False
            
        

Usando o método issuperset()

set_a = {1, 2, 3, 4, 5}
set_b = {1, 2, 3}
            
print(set_a.issuperset(set_b))  # Saída: True
print(set_b.issuperset(set_a))  # Saída: False