Summary  
This chapter explains how to access elements in a tuple by using both zero-based and negative indices within square brackets.

General domain of usage  
Movie catalog management

Adgang til elementer i en tuple er ligetil og fungerer på samme måde som med lister. Angiv blot indeksnummeret i kantede parenteser. Bemærk, at indeksering starter ved `0`, ligesom med lister.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the second movie
print(movies[1])

# Accessing the sixth movie
print(movies[5])

Tupler understøtter også negativ indeksering, hvor indekseringen starter fra slutningen. Det sidste element har således indekset `-1`, det næstsidste er `-2` osv.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the last movie
print(movies[-1])

# Accessing the fourth movie from the end
print(movies[-4])

I eksemplet ovenfor tilgås det sidste element (indekseret med `-1`) og det fjerde element fra slutningen (indekseret med `-4`).

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

    def test_first_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[0]
        _dynamic_test(
            self,
            user_code.first_movie == expected_value,
            f"The `first_movie` contains the correct value `{expected_value}`.",
            f"Expected `first_movie` to be `{expected_value}`, but got `{user_code.first_movie}`."
        )

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

    def test_last_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[-1]
        _dynamic_test(
            self,
            user_code.last_movie == expected_value,
            f"The `last_movie` contains the correct value `{expected_value}`.",
            f"Expected `last_movie` to be `{expected_value}`, but got `{user_code.last_movie}`."
        )

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

    def test_favorite_movies_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.favorite_movies, list),
            "The `favorite_movies` is of type `list`.",
            "Expected `favorite_movies` to be of type `list`."
        )

    def test_favorite_movies_contains_correct_elements(self):
        import user_code
        expected_values = [user_code.first_movie, user_code.last_movie]
        _dynamic_test(
            self,
            user_code.favorite_movies == expected_values,
            f"The `favorite_movies` list contains `{expected_values}`.",
            f"Expected `favorite_movies` to be `{expected_values}`, but got `{user_code.favorite_movies}`."
        )

    def test_indexing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'space_movies\s*\[', user_code_source),
            "Indexing is used to retrieve elements.",
            "Expected indexing to be used."
        )

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

test_main.py

Udforsk de grundlæggende datastrukturer i programmeringssproget Python, herunder lister, ordbøger, tupler og mængder, og lær hvordan de anvendes effektivt til at løse virkelige programmeringsudfordringer.

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

Hvad er et dictionary? Et dictionary er en ordnet samling, der kan ændres, men som ikke tillader dublerede poster. Det består af nøgle:værdi-par, som bruges til at optimere dets struktur.

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

Hvad er et set? I Python er et set en uordnet samling, der både er itererbar og muterbar, uden gentagne elementer. Selvom rækkefølgen af elementer i et set ikke er fastlagt, kan det indeholde forskellige elementer. En vigtig fordel ved at bruge sets frem for lister er deres meget effektive metode til at afgøre, om et element findes i settet.

Adgang til elementer i en tuple: indekseringsteknik

Løsning