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.

La méthode `index()` en Python est utilisée pour trouver la **première occurrence** d’un élément spécifié dans un tuple. Elle retourne l’indice de l’élément, ce qui est utile pour localiser la position de données spécifiques.
``` python
tuple_name.index(value)
```
La méthode retourne le premier indice où l’élément est trouvé.
Si l’élément n’est pas présent dans le tuple, une exception `ValueError` est levée.

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

Le résultat, `2`, indique que `"Tenet"` est le troisième élément (puisque l’indexation commence à `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

Explorez les structures de données fondamentales du langage de programmation Python, y compris les listes, les dictionnaires, les tuples et les ensembles, et découvrez comment les appliquer efficacement pour résoudre des défis de programmation réels.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée qui peut être modifiée. Elle permet également la présence d'éléments en double.

Qu'est-ce qu'un dictionnaire ? Un dictionnaire est une collection ordonnée et modifiable qui n'autorise pas les doublons. Il se compose de paires clé:valeur, utilisées pour optimiser sa structure.

Qu'est-ce qu'un tuple ? Un tuple est une collection ordonnée qui ne peut pas être modifiée. Il peut contenir des éléments dupliqués. Bien qu'il soit similaire à une liste, les valeurs d'un tuple peuvent être de tout type et sont indexées par des entiers. Bien que cela ne soit pas obligatoire, il est courant d'entourer les valeurs d'un tuple de parenthèses, ce qui les rend plus compréhensibles en Python.

Qu'est-ce qu'un ensemble ? En Python, un ensemble est une collection non ordonnée, à la fois itérable et mutable, sans éléments répétés. Bien que l'ordre des éléments dans un ensemble ne soit pas fixe, il peut inclure une variété d'éléments. Un avantage clé de l'utilisation des ensembles par rapport aux listes est leur méthode très efficace pour déterminer si un élément existe dans l'ensemble.

Recherche d’Éléments dans un Tuple

Solution