Summary  
This chapter explains how to use Python’s tuple `index()` method to locate the first occurrence of a specified element and return its position, raising a `ValueError` if the element is not found.

General domain of usage  
Media library management

Metoden `index()` i Python används för att hitta **första förekomsten** av ett angivet element i en tuple. Den returnerar elementets index, vilket är användbart när du behöver lokalisera positionen för specifik data.
``` python
tuple_name.index(value)
```
Metoden returnerar det första index där elementet hittas.
Om elementet inte finns i tuplen kastas ett `ValueError`-fel.

# Tuple of movies
movies = ("Inception", "Interstellar", "Tenet", "Dunkirk", "Memento")

# Find the index of "Tenet"
tenet_index = movies.index("Tenet")

print(f"'Tenet' is at index {tenet_index}.")

Resultatet, `2`, visar att `"Tenet"` är det tredje elementet (eftersom indexeringen börjar på `0`).

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

    def test_drama_movies_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.drama_movies, tuple),
            "The `drama_movies` variable is of type `tuple`.",
            "Expected `drama_movies` to be of type `tuple`."
        )

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

    def test_fight_club_index_is_correct(self):
        import user_code
        expected_index = user_code.drama_movies.index('Fight Club')
        _dynamic_test(
            self,
            user_code.fight_club_index == expected_index,
            f"The `fight_club_index` is `{expected_index}`.",
            f"Expected `fight_club_index` to be `{expected_index}`, but got `{user_code.fight_club_index}`."
        )

    def test_index_method_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'index\(', user_code_source),
            "The `index()` method is used to find the index of 'Fight Club'.",
            "Expected the `index()` method to be used."
        )

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


test_main.py

Utforska de grundläggande datastrukturerna i programmeringsspråket Python, inklusive listor, ordböcker, tupler och mängder, och lär dig hur dessa kan tillämpas effektivt för att lösa verkliga programmeringsproblem.

Vad är en lista? En lista är en ordnad samling som kan modifieras. Den tillåter även dubbletter av element.

Vad är ett dictionary? Ett dictionary är en ordnad samling som kan ändras, men tillåter inte dubbletter. Det består av nyckel:värde-par, vilka används för att optimera dess struktur.

Vad är en tuple? En tuple är en ordnad samling som inte kan ändras. Den kan innehålla dubbletter. Även om den liknar en lista kan värdena i en tuple vara av vilken typ som helst och indexeras med heltal. Det är vanligt, men inte obligatoriskt, att omsluta tuple-värden med parenteser för att göra dem lättare att förstå i Python.

Vad är en mängd? I Python är en mängd en oordnad samling som är både itererbar och muterbar, utan upprepade element. Även om ordningen på objekten i en mängd inte är fast, kan den innehålla olika typer av element. En viktig fördel med att använda mängder istället för listor är deras mycket effektiva metod för att avgöra om ett element finns i mängden.

Hitta Element i en Tuple: Använda index()-Metoden för Uppslagning

Lösning