For å endre verdier i en tuple, kan du bruke en teknikk som ligner på den for sletting. Fordi en tuple er uforanderlig, kan du ikke direkte endre elementene uten å støte på en feil.

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 å konvertere tuplen til en liste, kan du enkelt gjøre de ønskede endringene.

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 kurset vil du bli kjent med de grunnleggende datastrukturene i programmeringsspråket Python. Vi vil utforske bruken av Pythons innebygde datastrukturer som lister, ordbøker, tupler og mengder for å løse ulike utfordringer.

Hva er en liste? En liste er en ordnet samling som kan endres. Den tillater også dupliserte elementer.

Hva er en ordbok? En ordbok er en ordnet samling som kan endres, men den tillater ikke dupliserte oppføringer. Den består av `key:value`-par, som brukes til å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan ha dupliserte elementer. Selv om den ligner på en liste, kan verdiene i en tuple være av hvilken som helst type og er indeksert med heltall. Selv om det ikke er obligatorisk, er det vanlig å omslutte verdiene i en tuple med parenteser, noe som gjør dem lettere å forstå i Python.

Hva er et sett? I Python er et `set` en uordnet samling som er både `iterable` og `mutable`, uten gjentatte elementer. Selv om rekkefølgen av elementer i et sett ikke er fast, kan det inkludere en rekke elementer. En viktig fordel med å bruke sett over lister er deres svært effektive metode for å avgjøre om et element eksisterer innenfor settet.

Oppdatere Tuples i Python

Løsning

Oppdatere Tuples i Python

Løsning