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)

Om waarden binnen een tuple te wijzigen, kun je een techniek gebruiken die vergelijkbaar is met die voor het verwijderen. Omdat een tuple onveranderlijk is, kun je de elementen niet direct aanpassen zonder een foutmelding te krijgen.

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

Door de tuple echter om te zetten naar een lijst, kun je eenvoudig de gewenste wijzigingen aanbrengen.

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

Ontdek de fundamentele datastructuren van de programmeertaal Python, waaronder lijsten, woordenboeken, tuples en sets, en leer hoe u deze effectief kunt toepassen om programmeeruitdagingen uit de praktijk op te lossen.

Wat is een lijst? Een lijst is een geordende collectie die kan worden aangepast. Het staat ook dubbele elementen toe.

Wat is een dictionary? Een dictionary is een geordende, wijzigbare collectie die geen dubbele items toestaat. Het bestaat uit key:value-paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Een tuple kan dubbele elementen bevatten. Hoewel het lijkt op een lijst, kunnen de waarden in een tuple van elk type zijn en worden ze geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, wat het in Python overzichtelijker maakt.

Wat is een set? In Python is een set een ongeordende verzameling die zowel itereerbaar als muteerbaar is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan deze verschillende elementen bevatten. Een belangrijk voordeel van het gebruik van sets ten opzichte van lijsten is de zeer efficiënte methode om te bepalen of een element zich in de set bevindt.

Tuples Bijwerken in Python

Oplossing