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

In this course, you'll get to know the fundamental data structures of the Python programming language. We'll explore utilizing Python's native data structures like lists, dictionaries, tuples, and sets to tackle different 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

Awesome!

Accessing Elements in a Tuple: Indexing Technique

Solution

Awesome!