El método `index()` en Python se utiliza para encontrar la **primera ocurrencia** de un elemento especificado en una tupla. Devuelve el índice del elemento, lo cual es útil cuando necesitas localizar la posición de datos específicos.
``` python
tuple_name.index(value)
```
El método devuelve el primer índice donde se encuentra el elemento.
Si el elemento no está presente en la tupla, se lanza un `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}.")

El resultado, `2`, indica que `"Tenet"` es el tercer elemento (ya que la indexación comienza en `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

En este curso, conocerás las estructuras de datos fundamentales del lenguaje de programación Python. Exploraremos el uso de las estructuras de datos nativas de Python como listas, diccionarios, tuplas y conjuntos para abordar diferentes desafíos.

¿Qué es una lista? Una lista es una colección ordenada que se puede modificar. También permite elementos duplicados.

¿Qué es un diccionario? Un diccionario es una colección ordenada que se puede cambiar, pero no permite entradas duplicadas. Consiste en pares `clave:valor`, que se utilizan para optimizar su estructura.

¿Qué es una tupla? Una tupla es una colección ordenada que no puede ser alterada. Puede tener elementos duplicados. Aunque es similar a una lista, los valores en una tupla pueden ser de cualquier tipo y están indexados por enteros. Aunque no es obligatorio, es común encerrar los valores de una tupla entre paréntesis, lo que los hace más fáciles de entender en Python.

¿Qué es un conjunto? En Python, un `set` es una colección desordenada que es tanto `iterable` como `mutable`, sin elementos repetidos. Aunque el orden de los elementos en un conjunto no está fijado, puede incluir una variedad de elementos. Un beneficio clave de usar conjuntos sobre listas es su método altamente eficiente para determinar si un elemento existe dentro del conjunto.

Estructuras de Datos en Python

Encontrar Elementos en una Tupla

Solución

Encontrar Elementos en una Tupla

Solución