Summary  
This chapter explains how to access elements in a tuple by using both zero-based and negative indices within square brackets.

General domain of usage  
Movie catalog management

Accessing elements in a tuple is straightforward and works the same way as with lists. Simply specify the index number inside square brackets. Remember, indexing starts at `0`, just like with lists.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the second movie
print(movies[1])

# Accessing the sixth movie
print(movies[5])

Tuples also support negative indexing, where the indexing begins from the end. Thus, the last element has an index of `-1`, the second to last is `-2`, and so on.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the last movie
print(movies[-1])

# Accessing the fourth movie from the end
print(movies[-4])

In the example above, we access the last element (indexed at `-1`) and the fourth element from the end (indexed at `-4`).

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

    def test_first_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[0]
        _dynamic_test(
            self,
            user_code.first_movie == expected_value,
            f"The `first_movie` contains the correct value `{expected_value}`.",
            f"Expected `first_movie` to be `{expected_value}`, but got `{user_code.first_movie}`."
        )

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

    def test_last_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[-1]
        _dynamic_test(
            self,
            user_code.last_movie == expected_value,
            f"The `last_movie` contains the correct value `{expected_value}`.",
            f"Expected `last_movie` to be `{expected_value}`, but got `{user_code.last_movie}`."
        )

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

    def test_favorite_movies_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.favorite_movies, list),
            "The `favorite_movies` is of type `list`.",
            "Expected `favorite_movies` to be of type `list`."
        )

    def test_favorite_movies_contains_correct_elements(self):
        import user_code
        expected_values = [user_code.first_movie, user_code.last_movie]
        _dynamic_test(
            self,
            user_code.favorite_movies == expected_values,
            f"The `favorite_movies` list contains `{expected_values}`.",
            f"Expected `favorite_movies` to be `{expected_values}`, but got `{user_code.favorite_movies}`."
        )

    def test_indexing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'space_movies\s*\[', user_code_source),
            "Indexing is used to retrieve elements.",
            "Expected indexing to be used."
        )

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

test_main.py

Explore the fundamental data structures of the Python programming language, including lists, dictionaries, tuples, and sets, and learn how to apply them effectively to solve real-world programming challenges.

What is a list? A list is an ordered collection that can be modified. It also allows for duplicate elements.

What is a dictionary? A dictionary is an ordered collection that can be changed, but it doesn't allow duplicate entries. It consists of key:value pairs, which are used to optimize its structure.

What is a tuple? A tuple is an ordered collection that cannot be altered. It can have duplicate elements. While it's similar to a list, the values in a tuple can be of any type and are indexed by integers. Although not mandatory, it's common to enclose the values of a tuple in parentheses, making them easier to understand in Python.

What is a set? In Python, a set is an unordered collection that is both iterable and mutable, with no repeated elements. While the order of items in a set isn't fixed, it can include a variety of elements. A key benefit of using sets over lists is their highly efficient method for determining if an element exists within the set.

Accessing Elements in a Tuple: Indexing Technique

Solution