
I Python er det mulig å kombinere tupler. Dette innebærer å danne en ny tuple ved å slå sammen to eller flere eksisterende. Du kan oppnå dette med `+`-operatoren. Her er et eksempel for å illustrere.

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

I dette kurset vil du bli kjent med de grunnleggende datastrukturene i programmeringsspråket Python. Vi vil utforske bruken av Pythons innebygde datastrukturer som lister, ordbøker, tupler og mengder for å løse ulike utfordringer.

Hva er en liste? En liste er en ordnet samling som kan endres. Den tillater også dupliserte elementer.

Hva er en ordbok? En ordbok er en ordnet samling som kan endres, men den tillater ikke dupliserte oppføringer. Den består av `key:value`-par, som brukes til å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan ha dupliserte elementer. Selv om den ligner på en liste, kan verdiene i en tuple være av hvilken som helst type og er indeksert med heltall. Selv om det ikke er obligatorisk, er det vanlig å omslutte verdiene i en tuple med parenteser, noe som gjør dem lettere å forstå i Python.

Hva er et sett? I Python er et `set` en uordnet samling som er både `iterable` og `mutable`, uten gjentatte elementer. Selv om rekkefølgen av elementer i et sett ikke er fast, kan det inkludere en rekke elementer. En viktig fordel med å bruke sett over lister er deres svært effektive metode for å avgjøre om et element eksisterer innenfor settet.

Sammenkoble Tupler i Python: Slå Sammen Uforanderlige Sekvenser

Løsning

Sammenkoble Tupler i Python: Slå Sammen Uforanderlige Sekvenser

Løsning