Summary  
This chapter covers how to access elements in tuple sequences using both positive and negative indexing.

General domain of usage  
Sequence data manipulation

Alkioiden hakeminen tuplesta on yksinkertaista ja toimii samalla tavalla kuin listoissa. Määritä vain indeksinumero hakasulkeiden sisään. Muista, että indeksointi alkaa arvosta `0`, kuten listoissakin.

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

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

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

Tuplet tukevat myös negatiivista indeksointia, jolloin indeksointi alkaa lopusta. Näin viimeisellä alkiolla 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ä haetaan viimeinen alkio (indeksi `-1`) ja neljäs alkio lopusta (indeksi `-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, tuplisiin ja joukkoihin, sekä niiden tehokkaaseen hyödyntämiseen todellisten ohjelmointiongelmien ratkaisemisessa.

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

Mikä on sanakirja? Sanakirja on järjestetty kokoelma, jota voidaan muokata, mutta se ei salli päällekkäisiä merkintöjä. Se koostuu avain:arvo-pareista, joita käytetään rakenteen optimointiin.

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

Mikä on joukko? Pythonissa joukko on järjestämätön kokoelma, joka on iteroitava ja muokattavissa, eikä siinä ole toistuvia alkioita. Vaikka joukon alkioiden järjestys ei ole kiinteä, se voi sisältää erilaisia alkioita. Merkittävä etu joukkojen käyttämisessä listoihin verrattuna on niiden erittäin tehokas tapa selvittää, kuuluuko alkio joukkoon.

Indeksointitekniikka

Indeksointitekniikka

Ratkaisu