Summary
This chapter explains how to use the tuple.index() method to find the first occurrence of an element in a tuple and how to catch a ValueError if the element isn’t found.

General domain of usage
Searching for movie titles in a media collection

In this video, you will learn how to find elements in a Python tuple using the `index()` method. The lesson begins by explaining what the `index()` method does and how it helps you locate the position of a specific element in a tuple. You will see a step-by-step demonstration with a tuple of movie titles, where the code finds the index of 'Tenet' and prints its position. The video then guides you through an interactive task: using the `index()` method to find the position of 'Fight Club' in a tuple of drama movies. You'll see the solution, understand why the result is correct, and hear tips for handling situations when the element is not present in the tuple. By the end, you will confidently use the `index()` method to search for items in any Python tuple.
-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

Metoden `index()` i Python används för att hitta **första förekomsten** av ett angivet element i en tuple. Den returnerar indexet för elementet, 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`.

# 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`, indikerar 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 programmeringsutmaningar.

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

Vad är en dictionary? En dictionary är en ordnad samling som kan ändras, men den tillåter inte dubbletter. Den 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 duplicerade element. Ä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, vilket gör 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

Hitta Element i en Tuple

Lösning