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, è possibile combinare le tuple. Questo comporta la formazione di una nuova tupla unendo due o più tuple esistenti. Puoi farlo con l'operatore `+`. Ecco un esempio per illustrare.

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 questo corso, conoscerai le strutture dati fondamentali del linguaggio di programmazione Python. Esploreremo l'utilizzo delle strutture dati native di Python come liste, dizionari, tuples e sets per affrontare diverse sfide.

Cos'è una lista? Una lista è una collezione ordinata che può essere modificata. Consente anche elementi duplicati.

Cos'è un dizionario? Un dizionario è una raccolta ordinata che può essere modificata, ma non consente voci duplicate. Consiste in coppie `key:value`, che vengono utilizzate per ottimizzare la sua struttura.

Cos'è una tupla? Una tupla è una collezione ordinata che non può essere modificata. Può avere elementi duplicati. Anche se è simile a una lista, i valori in una tupla possono essere di qualsiasi tipo e sono indicizzati da numeri interi. Anche se non è obbligatorio, è comune racchiudere i valori di una tupla tra parentesi, rendendoli più facili da comprendere in Python.

Cos'è un set? In Python, un `set` è una collezione non ordinata che è sia `iterable` che `mutable`, senza elementi ripetuti. Sebbene l'ordine degli elementi in un set non sia fisso, può includere una varietà di elementi. Un vantaggio chiave dell'utilizzo dei set rispetto alle liste è il loro metodo altamente efficiente per determinare se un elemento esiste all'interno del set.

Concatenare Tuples in Python: Unire Sequenze Immutabili

Soluzione

Awesome!

Concatenare Tuples in Python: Unire Sequenze Immutabili

Soluzione