Summary  
This chapter explains how to create and work with nested lists in Python, demonstrating how to combine and organize multi-level list structures.  

General domain of usage  
Organizing geographic data (e.g., grouping cities by continent)

Los elementos dentro de una lista en Python también pueden ser listas. Esto forma lo que se denomina una "lista anidada" o "listas dentro de listas". Las listas anidadas son útiles para organizar estructuras de datos elaboradas, ya que permiten almacenar datos de varios niveles dentro de una sola lista.

Por ejemplo, puedes tener una lista donde algunos elementos son valores individuales y otros pueden ser listas en sí mismas. Aquí tienes un ejemplo sencillo:

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

print(cities)

### Uso de variables para listas anidadas
Este ejemplo muestra una lista anidada en la que el segundo y el cuarto elemento también son listas, y el cuarto elemento incluso contiene otra lista anidada dentro de él.

También puedes crear listas anidadas concatenando listas almacenadas en variables. Esto puede ser útil para hacer que tu código sea más legible. Por ejemplo:

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)

Aquí, primero se definen tres listas independientes para ciudades en Europa, Asia y América. Luego, se combinan las listas en una sola, `world_cities`, que se convierte en una lista anidada.

El ejemplo muestra que una lista anidada es una buena manera de organizar datos relacionados, como ciudades de diferentes continentes, de forma natural, intuitiva y ordenada.

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

Explora las estructuras de datos fundamentales del lenguaje de programación Python, incluyendo listas, diccionarios, tuplas y conjuntos, y aprende cómo aplicarlas de manera efectiva para resolver desafíos de programación del mundo real.

¿Qué es una lista? Una lista es una colección ordenada que puede modificarse. También permite elementos duplicados.

¿Qué es un diccionario? Un diccionario es una colección ordenada que puede modificarse, pero no permite entradas duplicadas. Consiste en pares clave:valor, que se utilizan para optimizar su estructura.

¿Qué es una tupla? Una tupla es una colección ordenada que no puede ser modificada. Puede contener elementos duplicados. Aunque es similar a una lista, los valores en una tupla pueden ser de cualquier tipo y están indexados por enteros. Aunque no es obligatorio, es común encerrar los valores de una tupla entre paréntesis, lo que facilita su comprensión en Python.

¿Qué es un conjunto? En Python, un conjunto es una colección desordenada que es tanto iterable como mutable, sin elementos repetidos. Aunque el orden de los elementos en un conjunto no está definido, puede incluir una variedad de elementos. Un beneficio clave de usar conjuntos en lugar de listas es su método altamente eficiente para determinar si un elemento existe dentro del conjunto.

Trabajando con Listas Anidadas en Python

Uso de variables para listas anidadas

Solución