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)

I Python gir lister deg mulighet til å få tilgang til individuelle elementer ved hjelp av deres indeks. Indeksering starter på `0`, noe som betyr at det første elementet i en liste har indeks `0`, det andre elementet har indeks `1`, og så videre. Dette kalles **nullindeksering**. For å få tilgang til et element, bruk hakeparenteser med indeksen til ønsket element.


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

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

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

I det neste eksempelet returnerer indeksen `0` det første elementet, 'Rome', mens indeksen `2` returnerer det tredje elementet, som er 'New York'. Husk at indeksen tilsvarer posisjonen minus én (n - 1).

### Negativ indeksering
Python støtter også **negativ indeksering**: dette gjør det mulig å få tilgang til elementer fra slutten av listen. Her representerer `-1` det siste elementet, `-2` representerer det nest siste elementet, og så videre. Negativ indeksering kan være svært nyttig når du ønsker å arbeide med en liste fra slutten uten å vite lengden på listen.

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

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

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

Forklaring:
1. `-1` henter det siste elementet 'Kioto';
2. `3` og `-2` refererer begge til det fjerde elementet 'Brasilia', én med positiv indeksering og én med negativ indeksering. Dette viser hvordan indeksering kan gå rundt i listen.

Positiv og negativ indeksering gir fleksibilitet ved tilgang til elementer i lister, enten fra begynnelsen eller slutten.

### Indeksering i nøstede lister
Tilgang til elementer i en nøstet liste krever flere indekser: den første indeksen velger underlisten, og den andre indeksen henter det spesifikke elementet i denne underlisten.

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

Bruksområder for indeksering av nestede lister inkluderer, men er ikke begrenset til, strukturert data som **regneark**, **matriser** eller **databaser**. Praktiske eksempler kan være tilgang til rader og kolonner i en 2D-matrise, hente detaljer fra lister med ansattoppføringer, eller trekke ut spesifikk informasjon, som bynavn eller kostnader fra reiseplaner eller nestede JSON-lignende strukturer.

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

Utforsk de grunnleggende datastrukturene i programmeringsspråket Python, inkludert lister, ordbøker, tupler og mengder, og lær hvordan disse kan brukes effektivt for å løse reelle programmeringsutfordringer.

Hva er en liste? En liste er en ordnet samling som kan endres. Den tillater også dupliserte elementer.

Hva er et dictionary? Et dictionary er en ordnet samling som kan endres, men det tillater ikke dupliserte oppføringer. Det består av nøkkel:verdi-par, som brukes for å optimalisere strukturen.

Hva er en tuple? En tuple er en ordnet samling som ikke kan endres. Den kan inneholde dupliserte elementer. Selv om den ligner på en liste, kan verdiene i en tuple være av hvilken som helst type og er indeksert med heltall. Selv om det ikke er påkrevd, er det vanlig å omslutte verdiene i en tuple med parenteser, noe som gjør dem lettere å forstå i Python.

Hva er et sett? I Python er et sett en uordnet samling som både er itererbar og muterbar, uten gjentatte elementer. Selv om rekkefølgen på elementene i et sett ikke er fast, kan det inneholde ulike typer elementer. En viktig fordel med å bruke sett fremfor lister er den svært effektive metoden for å avgjøre om et element finnes i settet.

Listeindeksering i Python: Effektiv Tilgang til Elementer

Negativ indeksering

Indeksering i nøstede lister

Løsning