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)

For at ændre værdier inden for en tuple, kan du bruge en teknik, der ligner den til sletning. Fordi en tuple er uforanderlig, kan du ikke direkte ændre dens elementer uden at støde på en fejl.

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

Men ved at konvertere tuplen til en liste, kan du nemt foretage de ønskede ændringer.

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

I dette kursus vil du lære de grundlæggende datastrukturer i Python-programmeringssproget at kende. Vi vil udforske brugen af Pythons indbyggede datastrukturer som lister, ordbøger, tuples og sæt til at tackle forskellige udfordringer.

Hvad er en liste? En liste er en ordnet samling, der kan ændres. Den tillader også dublerede elementer.

Hvad er en ordbog? En ordbog er en ordnet samling, der kan ændres, men den tillader ikke dublerede poster. Den består af `key:value` par, som bruges til at optimere dens struktur.

Hvad er en tuple? En tuple er en ordnet samling, der ikke kan ændres. Den kan have duplikerede elementer. Selvom den ligner en liste, kan værdierne i en tuple være af enhver type og er indekseret med heltal. Selvom det ikke er obligatorisk, er det almindeligt at omslutte værdierne i en tuple med parenteser, hvilket gør dem lettere at forstå i Python.

Hvad er et sæt? I Python er et `set` en uordnet samling, der både er `iterable` og `mutable`, uden gentagne elementer. Selvom rækkefølgen af elementer i et sæt ikke er fast, kan det inkludere en række forskellige elementer. En vigtig fordel ved at bruge sæt frem for lister er deres meget effektive metode til at bestemme, om et element findes inden for sættet.

Opdatering af Tuples i Python

Løsning

Awesome!

Opdatering af Tuples i Python

Løsning

Awesome!