Summary  
This chapter explains how to verify membership in a set using the in keyword and how to iterate through all elements of an unordered set with a for loop.  

General domain of usage  
Managing a movie collection.

Como os conjuntos são **não ordenados**, não é possível acessar seus elementos por índice como em uma lista ou tupla. No entanto, é possível:

- Verificar a existência de um elemento usando a palavra-chave `in`;
- Iterar pelos elementos utilizando um laço `for`.

### Verificando a existência com `in`
A palavra-chave `in` permite verificar se um elemento específico existe dentro de um conjunto:

# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Check if specific movies are in the set
is_inception_present = "Inception" in movies  # True
is_avatar_present = "Avatar" in movies        # False

# Print results
print(is_inception_present)  # Output: True
print(is_avatar_present)     # Output: False

Neste exemplo, utilizamos a palavra-chave `in` para verificar se filmes específicos estão presentes no conjunto `movies` e armazenamos o resultado como um valor booleano nas variáveis `is_inception_present` e `is_avatar_present`.

### Iterando por um conjunto com um laço `for`
É possível iterar sobre um conjunto utilizando um laço `for` para processar cada elemento individualmente. Como os conjuntos são não ordenados, a ordem da iteração é imprevisível.


# Define a set of favorite movies
movies = {"Inception", "Interstellar", "Tenet", "Dunkirk", "Memento"}

# Iterate through the set and print each movie title
print("Movie collection:")
for movie in movies:
    print(movie)

Cada elemento do conjunto é acessado uma vez durante a iteração.
A ordem dos elementos na saída pode variar.

import unittest
import importlib
import re

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movies'),
            "The `movies` set is declared.",
            "Expected `movies` to be declared."
        )

    def test_movies_is_set(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movies, set),
            "The `movies` is of type `set`.",
            "Expected `movies` to be of type `set`."
        )

    def test_is_first_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_first_movie_present'),
            "The `is_first_movie_present` variable is declared.",
            "Expected `is_first_movie_present` to be declared."
        )

    def test_is_second_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_second_movie_present'),
            "The `is_second_movie_present` variable is declared.",
            "Expected `is_second_movie_present` to be declared."
        )

    def test_is_third_movie_present_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'is_third_movie_present'),
            "The `is_third_movie_present` variable is declared.",
            "Expected `is_third_movie_present` to be declared."
        )

    def test_is_first_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_first_movie_present is True,
            "The `is_first_movie_present` is correctly set to `True`.",
            "Expected `is_first_movie_present` to be `True`, but got `False`."
        )

    def test_is_second_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_second_movie_present is False,
            "The `is_second_movie_present` is correctly set to `False`.",
            "Expected `is_second_movie_present` to be `False`, but got `True`."
        )

    def test_is_third_movie_present_correct(self):
        import user_code
        _dynamic_test(
            self,
            user_code.is_third_movie_present is True,
            "The `is_third_movie_present` is correctly set to `True`.",
            "Expected `is_third_movie_present` to be `True`, but got `False`."
        )

    def test_in_keyword_used_three_times(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        in_keyword_count = len(re.findall(r'in\s+movies', user_code_source))
        _dynamic_test(
            self,
            in_keyword_count == 3,
            "The `in` keyword is used exactly three times in the code.",
            f"Expected the `in` keyword to be used exactly three times, but found {in_keyword_count} occurrences."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Explore as estruturas de dados fundamentais da linguagem de programação Python, incluindo listas, dicionários, tuplas e conjuntos, e aprenda a aplicá-las de forma eficaz para resolver desafios de programação do mundo real.

O que é uma lista? Uma lista é uma coleção ordenada que pode ser modificada. Ela também permite elementos duplicados.

O que é um dicionário? Um dicionário é uma coleção ordenada que pode ser modificada, mas não permite entradas duplicadas. Ele consiste em pares chave:valor, que são utilizados para otimizar sua estrutura.

O que é uma tupla? Uma tupla é uma coleção ordenada que não pode ser alterada. Ela pode conter elementos duplicados. Embora seja semelhante a uma lista, os valores em uma tupla podem ser de qualquer tipo e são indexados por inteiros. Embora não seja obrigatório, é comum envolver os valores de uma tupla entre parênteses, tornando-os mais fáceis de compreender em Python.

O que é um set? Em Python, um set é uma coleção não ordenada que é iterável e mutável, sem elementos repetidos. Embora a ordem dos itens em um set não seja fixa, ele pode incluir uma variedade de elementos. Um benefício importante do uso de sets em relação a listas é seu método altamente eficiente para determinar se um elemento existe no set.

Acessando Elementos em um Conjunto: Iteração e Teste de Pertencimento

Verificando a existência com `in`

Iterando por um conjunto com um laço `for`

Solução

Acessando Elementos em um Conjunto: Iteração e Teste de Pertencimento

Verificando a existência com in

Iterando por um conjunto com um laço for

Solução

Verificando a existência com `in`

Iterando por um conjunto com um laço `for`