Summary
This chapter explains how to merge immutable sequences in Python by concatenating tuples with the + operator.

General domain of usage
Media cataloging


In Python, it's possible to combine tuples. This involves forming a new tuple by merging two or more existing ones. You can accomplish this with the `+` operator. Here's an example to illustrate.

movie_titles = ("Inception", "Interstellar", "Dunkirk")
release_years = (2010, 2014, 2017)

# Concatenate the tuples
combined_tuple = movie_titles + release_years

print(combined_tuple)

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

    def test_movies_about_animals_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.animal_movies, tuple),
            "The `animal_movies` is of type `tuple`.",
            "Expected `animal_movies` to be of type `tuple`."
        )

    def test_movies_about_animals_contains_correct_values(self):
        import user_code
        expected_values = tuple(user_code.new_movies)
        _dynamic_test(
            self,
            user_code.animal_movies == expected_values,
            f"The `animal_movies` contains `{expected_values}`.",
            f"Expected `animal_movies` to contain `{expected_values}`, but got `{user_code.animal_movies}`."
        )

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

    def test_movie_poster_is_tuple(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.movie_poster, tuple),
            "The `movie_poster` is of type `tuple`.",
            "Expected `movie_poster` to be of type `tuple`."
        )

    def test_movie_poster_contains_correct_values(self):
        import user_code
        expected_values = user_code.space_movies + user_code.animal_movies
        _dynamic_test(
            self,
            set(user_code.movie_poster) == set(expected_values),
            f"The `movie_poster` contains `{expected_values}`.",
            f"Expected `movie_poster` to contain `{expected_values}`, but got `{user_code.movie_poster}`."
        )

    def test_tuple_function_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'tuple\s*\(', user_code_source),
            "The `tuple()` function is used.",
            "Expected the `tuple()` function to be used."
        )

    def test_concatenation_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'\+', user_code_source),
            "The `+` operator is used for tuple concatenation.",
            "Expected the `+` operator to be used for tuple concatenation."
        )

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.

Concatenating Tuples in Python: Merging Immutable Sequences

Solution

Awesome!

Concatenating Tuples in Python: Merging Immutable Sequences

Solution

Awesome!