Summary  
This chapter demonstrates how to work around tuple immutability by converting a tuple to a list, updating its elements, and converting it back to a tuple.

General domain of usage  
Entertainment applications (e.g., managing movie data)

Para modificar valores dentro de uma tupla, é possível utilizar uma técnica semelhante à de exclusão. Como a tupla é imutável, não é possível alterar seus elementos diretamente sem gerar um erro.

movie_ratings = (8.8, 9.0, 7.5, 6.8)
# Attempting to modify a tuple directly
movie_ratings[1] = 8.9  # Output: Error: 'tuple' object does not support item assignment

No entanto, convertendo a tupla para uma lista, é possível realizar as alterações desejadas com facilidade.

current_movies = ("Inception", "Interstellar", "Tenet", "Dunkirk")

# Step 1: Convert the tuple to a list
movies_list = list(current_movies)

# Step 2: Update the second and third movie titles
movies_list[1] = "Memento"
movies_list[2] = "The Prestige"

# Step 3: Convert the list back to a tuple
current_movies = tuple(movies_list)

print(current_movies)

import unittest
import importlib
import re
import py_compile

def check_syntax_errors(test_case):
    import user_code
    try:
        py_compile.compile(user_code.__file__, doraise=False) 
    except py_compile.PyCompileError as e:
        error_message = f"Syntax or indentation error detected in user_code: {str(e)}"
        test_case._testMethodName = error_message 
        test_case.fail(error_message) 

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_movie_genres_is_declared(self):
        check_syntax_errors(self)
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'movie_genres'),
            "The `movie_genres` variable is declared.",
            "Expected `movie_genres` to be declared."
        )

    def test_movie_genres_is_tuple(self):
        check_syntax_errors(self)
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movie_genres, tuple),
            "The `movie_genres` is of type `tuple`.",
            "Expected `movie_genres` to be of type `tuple`."
        )

    def test_movie_genres_contains_correct_values(self):
        check_syntax_errors(self)
        import user_code
        expected_values = ("Action", "Comedy", "Thriller", "Adventure", "Sci-Fi")
        _dynamic_test(
            self,
            user_code.movie_genres == expected_values,
            f"The `movie_genres` contains `{expected_values}`.",
            f"Expected `movie_genres` to contain `{expected_values}`, but got `{user_code.movie_genres}`."
        )

    def test_temp_list_deleted(self):
        check_syntax_errors(self)
        import user_code
        _dynamic_test(
            self,
            not hasattr(user_code, 'temp_list'),
            "The `temp_list` variable was deleted.",
            "Expected `temp_list` to be deleted."
        )

    def test_list_function_used(self):
        check_syntax_errors(self)
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'list\s*\(', user_code_source),
            "The `list()` function is used for tuple conversion.",
            "Expected the `list()` function to be used for tuple conversion."
        )

    def test_tuple_function_used(self):
        check_syntax_errors(self)
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'tuple\s*\(', user_code_source),
            "The `tuple()` function is used for conversion back to a tuple.",
            "Expected the `tuple()` function to be used for conversion back to a tuple."
        )

    def test_del_statement_used(self):
        check_syntax_errors(self)
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'del\s+temp_list', user_code_source),
            "The `del` statement is used to delete `temp_list`.",
            "Expected the `del` statement to be used to delete `temp_list`."
        )

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.

Atualizando Tuplas em Python

Solução