Summary  
This chapter covers creating and manipulating nested lists in Python to group related items into sublists, access elements via multiple indices, and improve code clarity by assigning sublists to named variables.  

General domain of usage  
Organizing cities by continent

In this video, you will explore the concept of nested lists in Python. Learn how lists can contain other lists as elements, forming powerful structures for organizing complex data. We'll walk through simple examples, such as mixing individual items and lists within a parent list, and progress to creating nested lists using variables for better readability and structure. Discover practical use cases, like grouping cities by continent in a travel wishlist, and see how to construct and access nested lists step by step. By the end, you'll understand how nested lists help you organize related data intuitively and how to build them in your own Python projects.
-- video metadata (use this info when making a video) --

Cut all examples of code to a minimum. Show only the essential code. Show code no longer than 10 lines. Remove all possible pieces to demonstrate some code feature. You may show not full code that will not start, but still demonstrates some feature theoritacally.
If code is longer than 8 lines, move code output  blocks to second column.

Elementer i en liste i Python kan også være lister. Dette kalles en "nøstet liste" eller "lister i lister." Nøstede lister er kraftige for å organisere avanserte datastrukturer, siden du kan lagre data på flere nivåer i én liste.

For eksempel kan du ha en liste der noen elementer er enkeltverdier, mens andre kan være lister i seg selv. Her er et enkelt eksempel:

cities = ["London", ["Paris", "Madrid"], "Rome", ["Bangkok", ["New York", "Los Angeles"]]]

print(cities)

### Bruk av variabler for nøstede lister
Dette eksemplet viser en nøstet liste der det andre og fjerde elementet også er lister, og det fjerde elementet til og med inneholder en ny nøstet liste.

Du kan også lage nøstede lister ved å sette sammen lister som ligger i variabler. Dette kan gjøre koden din mer lesbar. For eksempel:

europe_cities = ["Paris", "Berlin", "Rome"]
asia_cities = ["Tokyo", "Seoul", "Bangkok"]
america_cities = ["New York", "Los Angeles", "Chicago"]

world_cities = [europe_cities, asia_cities, america_cities]

print(world_cities)

Først defineres tre uavhengige lister for byer i Europa, Asia og Amerika. Deretter kombineres listene til én, `world_cities`, som blir en nøstet liste.

Eksempelet viser at en nøstet liste er en god måte å organisere relatert data på, som for eksempel byer fra ulike kontinenter, på en naturlig, intuitiv og oversiktlig måte.

import unittest
from contextlib import redirect_stdout
import io
import importlib
import user_code

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_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'first_city'),
            "The `first_city` list is declared.",
            "Expected `first_city` to be declared."
        )

    def test_second_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'second_city'),
            "The `second_city` list is declared.",
            "Expected `second_city` to be declared."
        )

    def test_third_city_list_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'third_city'),
            "The `third_city` list is declared.",
            "Expected `third_city` to be declared."
        )

    def test_first_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.first_city, list),
            "The `first_city` is of type `list`.",
            f"Expected `first_city` to be of type `list`, but got {type(user_code.first_city)}."
        )

    def test_second_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.second_city, list),
            "The `second_city` is of type `list`.",
            f"Expected `second_city` to be of type `list`, but got {type(user_code.second_city)}."
        )

    def test_third_city_of_type_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.third_city, list),
            "The `third_city` is of type `list`.",
            f"Expected `third_city` to be of type `list`, but got {type(user_code.third_city)}."
        )

    def test_first_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.first_city[0], str),
                 isinstance(user_code.first_city[1], str),
                 isinstance(user_code.first_city[2], (int, float))]),
            "Elements of `first_city` are of types (str, str, int/float).",
            "Expected elements of `first_city` to be of types (str, str, int/float)."
        )

    def test_second_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.second_city[0], str),
                 isinstance(user_code.second_city[1], str),
                 isinstance(user_code.second_city[2], (int, float))]),
            "Elements of `second_city` are of types (str, str, int/float).",
            "Expected elements of `second_city` to be of types (str, str, int/float)."
        )

    def test_third_list_element_types(self):
        _dynamic_test(
            self,
            all([isinstance(user_code.third_city[0], str),
                 isinstance(user_code.third_city[1], str),
                 isinstance(user_code.third_city[2], (int, float))]),
            "Elements of `third_city` are of types (str, str, int/float).",
            "Expected elements of `third_city` to be of types (str, str, int/float)."
        )

    def test_travel_wishlist_is_declared(self):
        _dynamic_test(
            self,
            hasattr(user_code, 'travel_wishlist'),
            "The `travel_wishlist` is declared.",
            "Expected `travel_wishlist` to be declared."
        )

    def test_travel_wishlist_is_list(self):
        _dynamic_test(
            self,
            isinstance(user_code.travel_wishlist, list),
            "The `travel_wishlist` is of type `list`.",
            f"Expected `travel_wishlist` to be of type `list`, but got {type(user_code.travel_wishlist)}."
        )

    def test_travel_wishlist_contains_nested_lists(self):
        travel_wishlist = user_code.travel_wishlist
        _dynamic_test(
            self,
            len(travel_wishlist) >= 3,
            "The `travel_wishlist` contains at least 3 nested lists.",
            f"Expected `travel_wishlist` to contain at least 3 nested lists, but got {len(travel_wishlist)}."
        )

        for i, sublist in enumerate(travel_wishlist):
            _dynamic_test(
                self,
                isinstance(sublist, list),
                f"Element {i+1} of `travel_wishlist` is a list.",
                f"Expected element {i+1} of `travel_wishlist` to be a list."
            )
            _dynamic_test(
                self,
                len(sublist) == 3,
                f"Nested list {i+1} contains exactly 3 elements.",
                f"Expected nested list {i+1} to contain exactly 3 elements."
            )
            _dynamic_test(
                self,
                all([isinstance(sublist[0], str), isinstance(sublist[1], str), isinstance(sublist[2], (int, float))]),
                f"Nested list {i+1} elements are of types (str, str, int/float).",
                f"Expected elements of nested list {i+1} to be of types (str, str, int/float)."
            )

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 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.

Arbeide med nestede lister i Python

Bruk av variabler for nøstede lister

Løsning