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

General domain of usage
Media cataloging


Pythonissa on mahdollista yhdistää tupleja. Tämä tarkoittaa uuden tuplen muodostamista yhdistämällä kaksi tai useampia olemassa olevia tupleja. Voit tehdä tämän `+` operaattorilla. Tässä on esimerkki havainnollistamaan.

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

Tässä kurssissa tutustut Python-ohjelmointikielen perus tietorakenteisiin. Tutkimme Pythonin natiivien tietorakenteiden, kuten listojen, sanakirjojen, tuplien ja joukkojen, hyödyntämistä erilaisten haasteiden ratkaisemiseksi.

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

Mikä on sanakirja? Sanakirja on järjestetty kokoelma, jota voidaan muuttaa, mutta se ei salli päällekkäisiä merkintöjä. Se koostuu `key:value` pareista, joita käytetään sen rakenteen optimoimiseen.

Mikä on tuple? Tuple on järjestetty kokoelma, jota ei voi muuttaa. Se voi sisältää päällekkäisiä elementtejä. Vaikka se on samanlainen kuin lista, tuplen arvot voivat olla mitä tahansa tyyppiä ja ne indeksoidaan kokonaisluvuilla. Vaikka se ei ole pakollista, on yleistä sulkea tuplen arvot sulkuihin, mikä tekee niistä helpommin ymmärrettäviä Pythonissa.

Mikä on sarja? Pythonissa `set` on järjestämätön kokoelma, joka on sekä `iterable` että `muokattava`, ilman toistuvia elementtejä. Vaikka sarjan elementtien järjestys ei ole kiinteä, se voi sisältää monenlaisia elementtejä. Keskeinen etu sarjojen käytössä listoihin verrattuna on niiden erittäin tehokas menetelmä määrittää, onko elementti olemassa sarjassa.

Tuplien Yhdistäminen Pythonissa: Merging Muuttumattomien Sekvenssien Yhdistäminen

Ratkaisu

Awesome!

Tuplien Yhdistäminen Pythonissa: Merging Muuttumattomien Sekvenssien Yhdistäminen

Ratkaisu

Awesome!