
In Python ist es möglich, Tupel zu kombinieren. Dies beinhaltet das Bilden eines neuen Tupels durch das Zusammenführen von zwei oder mehr bestehenden. Dies kann mit dem `+` Operator erreicht werden. Hier ist ein Beispiel zur Veranschaulichung.

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 diesem Kurs lernen Sie die grundlegenden Datenstrukturen der Programmiersprache Python kennen. Wir werden die Nutzung von Pythons nativen Datenstrukturen wie Listen, Wörterbüchern, Tupeln und Mengen erkunden, um verschiedene Herausforderungen zu bewältigen.

Was ist eine Liste? Eine Liste ist eine geordnete Sammlung, die modifiziert werden kann. Sie erlaubt auch doppelte Elemente.

Was ist ein Wörterbuch? Ein Wörterbuch ist eine geordnete Sammlung, die geändert werden kann, aber keine doppelten Einträge zulässt. Es besteht aus `key:value`-Paaren, die zur Optimierung seiner Struktur verwendet werden.

Was ist ein Tupel? Ein Tupel ist eine geordnete Sammlung, die nicht verändert werden kann. Es kann doppelte Elemente enthalten. Obwohl es einer Liste ähnlich ist, können die Werte in einem Tupel von jedem Typ sein und werden durch ganze Zahlen indiziert. Obwohl es nicht zwingend erforderlich ist, ist es üblich, die Werte eines Tupels in Klammern zu setzen, um sie in Python leichter verständlich zu machen.

Was ist eine Menge? In Python ist eine `set` eine ungeordnete Sammlung, die sowohl `iterierbar` als auch `veränderbar` ist, ohne wiederholte Elemente. Während die Reihenfolge der Elemente in einer Menge nicht festgelegt ist, kann sie eine Vielzahl von Elementen enthalten. Ein wesentlicher Vorteil der Verwendung von Mengen gegenüber Listen ist ihre hocheffiziente Methode zur Bestimmung, ob ein Element innerhalb der Menge existiert.

Verkettung von Tupeln in Python: Zusammenführen Unveränderlicher Sequenzen

Lösung

Verkettung von Tupeln in Python: Zusammenführen Unveränderlicher Sequenzen

Lösung