Summary  
This chapter covers how to merge immutable sequence types by concatenating tuples using the `+` operator to produce a new sequence.

General domain of usage  
Data processing and manipulation


Pythonissa on mahdollista yhdistää tupleja. Tämä tarkoittaa uuden tuplen muodostamista yhdistämällä kaksi tai useampia olemassa olevia tupleja. Tämä onnistuu käyttämällä `+`-operaattoria. Alla on esimerkki havainnollistamaan tätä.

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

Tutustu Python-ohjelmointikielen keskeisiin tietorakenteisiin, kuten listoihin, sanakirjoihin, tuplihin ja joukkoihin, sekä opi hyödyntämään niitä tehokkaasti todellisten ohjelmointiongelmien ratkaisemisessa.

Mikä on lista? Lista on järjestetty kokoelma, jota voidaan muokata. Se sallii myös päällekkäiset alkiot.

Immutanttien Sekvenssien Yhdistäminen Pythonissa

Ratkaisu

Immutanttien Sekvenssien Yhdistäminen Pythonissa

Ratkaisu