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

De methode `index()` in Python wordt gebruikt om de **eerste voorkomst** van een gespecificeerd element in een tuple te vinden. Het retourneert de index van het element, wat handig is wanneer je de positie van specifieke gegevens moet lokaliseren.
``` python
tuple_name.index(value)
```
De methode retourneert de eerste index waar het element wordt gevonden.
Als het element niet aanwezig is in de tuple, wordt een `ValueError` gegenereerd.

# 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}.")

Het resultaat, `2`, geeft aan dat `"Tenet"` het derde element is (aangezien indexering begint bij `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

In deze cursus maak je kennis met de fundamentele datastructuren van de programmeertaal Python. We zullen onderzoeken hoe je gebruik kunt maken van Python's native datastructuren zoals lijsten, dictionaries, tuples en sets om verschillende uitdagingen aan te pakken.

Wat is een lijst? Een lijst is een geordende verzameling die kan worden gewijzigd. Het staat ook dubbele elementen toe.

Wat is een woordenboek? Een woordenboek is een geordende verzameling die kan worden gewijzigd, maar het staat geen dubbele invoer toe. Het bestaat uit `key:value` paren, die worden gebruikt om de structuur te optimaliseren.

Wat is een tuple? Een tuple is een geordende verzameling die niet kan worden gewijzigd. Het kan dubbele elementen bevatten. Hoewel het vergelijkbaar is met een lijst, kunnen de waarden in een tuple van elk type zijn en worden geïndexeerd door gehele getallen. Hoewel het niet verplicht is, is het gebruikelijk om de waarden van een tuple tussen haakjes te plaatsen, waardoor ze gemakkelijker te begrijpen zijn in Python.

Wat is een set? In Python is een `set` een ongeordende verzameling die zowel `iterable` als `mutable` is, zonder herhaalde elementen. Hoewel de volgorde van items in een set niet vastligt, kan het een verscheidenheid aan elementen bevatten. Een belangrijk voordeel van het gebruik van sets boven lijsten is hun zeer efficiënte methode om te bepalen of een element binnen de set bestaat.

Elementen Vinden in een Tuple: De index() Methode Gebruiken voor Opzoeken

Oplossing

Awesome!

Elementen Vinden in een Tuple: De index() Methode Gebruiken voor Opzoeken

Oplossing