Summary  
This chapter explains how to access elements in a tuple by using both zero-based and negative indices within square brackets.

General domain of usage  
Movie catalog management

Elementtien käsittely tuplessa on yksinkertaista ja toimii samalla tavalla kuin listoissa. Määritä vain indeksinumero hakasulkeiden sisällä. Muista, että indeksointi alkaa `0`:sta, aivan kuten listoissa.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the second movie
print(movies[1])

# Accessing the sixth movie
print(movies[5])

Tuplat tukevat myös negatiivista indeksointia, jossa indeksointi alkaa lopusta. Näin ollen viimeisellä elementillä on indeksi `-1`, toiseksi viimeisellä `-2` ja niin edelleen.

movies = ("Inception", "Interstellar", "The Dark Knight", "Tenet", "Dunkirk", "Memento", "Following")

# Accessing the last movie
print(movies[-1])

# Accessing the fourth movie from the end
print(movies[-4])

Yllä olevassa esimerkissä haemme viimeisen elementin (indeksoitu `-1`) ja neljännen elementin lopusta (indeksoitu `-4`).

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_first_movie_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'first_movie'),
            "The `first_movie` variable is declared.",
            "Expected `first_movie` to be declared."
        )

    def test_first_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[0]
        _dynamic_test(
            self,
            user_code.first_movie == expected_value,
            f"The `first_movie` contains the correct value `{expected_value}`.",
            f"Expected `first_movie` to be `{expected_value}`, but got `{user_code.first_movie}`."
        )

    def test_last_movie_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'last_movie'),
            "The `last_movie` variable is declared.",
            "Expected `last_movie` to be declared."
        )

    def test_last_movie_is_correct(self):
        import user_code
        expected_value = user_code.space_movies[-1]
        _dynamic_test(
            self,
            user_code.last_movie == expected_value,
            f"The `last_movie` contains the correct value `{expected_value}`.",
            f"Expected `last_movie` to be `{expected_value}`, but got `{user_code.last_movie}`."
        )

    def test_favorite_movies_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'favorite_movies'),
            "The `favorite_movies` variable is declared.",
            "Expected `favorite_movies` to be declared."
        )

    def test_favorite_movies_is_list(self):
        import user_code
        _dynamic_test(
            self,
            isinstance(user_code.favorite_movies, list),
            "The `favorite_movies` is of type `list`.",
            "Expected `favorite_movies` to be of type `list`."
        )

    def test_favorite_movies_contains_correct_elements(self):
        import user_code
        expected_values = [user_code.first_movie, user_code.last_movie]
        _dynamic_test(
            self,
            user_code.favorite_movies == expected_values,
            f"The `favorite_movies` list contains `{expected_values}`.",
            f"Expected `favorite_movies` to be `{expected_values}`, but got `{user_code.favorite_movies}`."
        )

    def test_indexing_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        _dynamic_test(
            self,
            re.search(r'space_movies\s*\[', user_code_source),
            "Indexing is used to retrieve elements.",
            "Expected indexing to be used."
        )

if __name__ == '__main__':
    unittest.main()

test_main.py

Tutustu Python-ohjelmointikielen keskeisiin tietorakenteisiin, kuten listoihin, sanakirjoihin, tupliin 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 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.

Elementtien Käsittely Tuplessa: Indexing Tekniikka

Ratkaisu