Summary  
This chapter explains how to access and assign list elements using zero-based and negative indexing in Python, including retrieving items from nested lists through multi-level indices.

General domain of usage  
Structured data handling (e.g., working with matrices)

Pythonissa listojen yksittäisiin alkioihin pääsee käsiksi niiden indeksin avulla. Indeksointi alkaa arvosta `0`, eli listan ensimmäinen alkio on indeksissä `0`, toinen alkio indeksissä `1` ja niin edelleen. Tätä kutsutaan **nollaindeksoinniksi**. Alkion hakemiseen käytetään hakasulkeita ja halutun alkion indeksiä.


cities = ["Rome", "London", "New York", "Brasilia", "Kioto"]

# Getting the first element
print(cities[0])

# Getting the third element
print(cities[2])

Seuraavassa esimerkissä indeksi `0` palauttaa ensimmäisen alkion, 'Rome', kun taas indeksi `2` palauttaa kolmannen alkion, joka on 'New York'. Muista, että indeksi vastaa sijaintia miinus yksi (n - 1).

### Negatiivinen indeksointi
Python tukee myös **negatiivista indeksointia**: tämän avulla voit hakea alkioita listan lopusta käsin. Tässä `-1` tarkoittaa viimeistä alkiota, `-2` toiseksi viimeistä alkiota ja niin edelleen. Negatiivinen indeksointi on hyödyllistä, kun haluat käsitellä listaa lopusta alkaen ilman, että tiedät sen pituutta.

cities = ["Rome", "London", "New York", "Brasilia", "Kioto"]

# Getting the last element
print(cities[-1])

# Getting the fourth element
print(cities[3], cities[-2])

Selitys:
1. `-1` hakee viimeisen alkion 'Kioto';
2. `3` ja `-2` viittaavat molemmat neljänteen alkioon 'Brasilia', toinen positiivisella ja toinen negatiivisella indeksoinnilla. Tämä havainnollistaa, kuinka indeksointi kiertää listan läpi.

Positiivinen ja negatiivinen indeksointi lisäävät joustavuutta listan alkioiden hakemiseen joko alusta tai lopusta.

### Sisäkkäisten listojen indeksointi
Alkioiden hakeminen sisäkkäisestä listasta vaatii useita indeksejä: ensimmäinen indeksi valitsee alilistan ja toinen indeksi hakee tietyn alkion kyseisestä alilistasta.

cities = [
    ["Paris", "France", 2000], 
    ["Tokyo", "Japan", 3000], 
    ["New York", "USA", 2500]
]

# Accessing the first sublist
print(cities[0])  # Output: ['Paris', 'France', 2000]

# Accessing the city name in the second sublist
print(cities[1][0])  # Output: Tokyo

# Accessing the cost of the trip in the third sublist
print(cities[2][2])  # Output: 2500

Sisäkkäisten listojen indeksoinnin käyttökohteita ovat muun muassa rakenteiset tiedot, kuten **taulukkolaskentaohjelmat**, **matriisit** tai **tietokannat**. Käytännön esimerkkejä ovat rivien ja sarakkeiden hakeminen 2D-matriisista, tietojen noutaminen työntekijälistoista tai tiettyjen tietojen, kuten kaupunkien nimien tai matkakustannusten, poimiminen matkasuunnitelmista tai sisäkkäisistä JSON-tyyppisistä rakenteista.

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code
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_cities_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'cities'),
            "The `cities` list is declared.",
            "Expected the `cities` list to be declared."
        )

    def test_second_variable_correctly_assigned(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'second') and user_code.second == user_code.cities[1],
            "The `second` variable is correctly assigned as the second element of the list.",
            f"Expected `second` to be assigned to 'Tokyo', but got '{getattr(user_code, 'first', None)}'."
        )

    def test_last_variable_correctly_assigned(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'last') and user_code.last == user_code.cities[-1],
            "The `last` variable is correctly assigned as the last element of the list.",
            f"Expected `last` to be assigned to 'Berlin', but got '{getattr(user_code, 'last', None)}'."
        )
    def test_indexing_is_used(self):
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()
        actual = re.search(r'cities\s*\[', user_code_source)
        _dynamic_test(
          self,
          actual,
          "The indexing is used to find the elements.",
          "Expected using indexing to find the elements."
        )

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

test_main.py

Tutustu Python-ohjelmointikielen keskeisiin tietorakenteisiin, kuten listoihin, sanakirjoihin, tuplihin 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ä sisällä 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 menetelmä tarkistaa, kuuluuko alkio joukkoon.

Listojen Indeksointi Pythonissa: Alkioiden Tehokas Käsittely

Negatiivinen indeksointi

Sisäkkäisten listojen indeksointi

Ratkaisu