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)

Les éléments d'une liste en Python peuvent également être des listes. Cela forme ce que l'on appelle une « liste imbriquée » ou « des listes dans des listes ». Les listes imbriquées sont puissantes pour organiser des structures de données élaborées, car elles permettent de stocker des données à plusieurs niveaux dans une seule liste.

Par exemple, vous pouvez avoir une liste où certains éléments sont de simples valeurs, tandis que d'autres sont eux-mêmes des listes. Voici un exemple simple :

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

print(cities)

### Utilisation de variables pour les listes imbriquées
Cet exemple illustre une liste imbriquée dans laquelle le deuxième et le quatrième élément sont également des listes, et le quatrième élément contient même une autre liste imbriquée à l'intérieur.

Vous pouvez aussi créer des listes imbriquées en concaténant des listes stockées dans des variables. Cela peut être utile pour rendre votre code plus lisible. Par exemple :

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)

Ici, nous définissons d'abord trois listes indépendantes pour les villes d'Europe, d'Asie et des Amériques. Nous combinons ensuite ces listes en une seule, `world_cities`, qui devient une liste imbriquée.

Cet exemple montre qu'une liste imbriquée est un moyen efficace d'organiser des données liées, comme des villes de différents continents, de manière naturelle, intuitive et structurée.

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

Explorez les structures de données fondamentales du langage de programmation Python, y compris les listes, les dictionnaires, les tuples et les ensembles, et découvrez comment les appliquer efficacement pour résoudre des problèmes de programmation concrets.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée pouvant être modifiée. Elle permet également la présence d'éléments en double.

Qu'est-ce qu'un dictionnaire ? Un dictionnaire est une collection ordonnée et modifiable qui n'autorise pas les doublons. Il se compose de paires clé:valeur, utilisées pour optimiser sa structure.

Qu'est-ce qu'un tuple ? Un tuple est une collection ordonnée qui ne peut pas être modifiée. Il peut contenir des éléments dupliqués. Bien qu'il soit similaire à une liste, les valeurs d'un tuple peuvent être de tout type et sont indexées par des entiers. Bien que cela ne soit pas obligatoire, il est courant d'entourer les valeurs d'un tuple de parenthèses, ce qui les rend plus faciles à comprendre en Python.

Qu'est-ce qu'un ensemble ? En Python, un ensemble est une collection non ordonnée, à la fois itérable et mutable, sans éléments répétés. Bien que l'ordre des éléments dans un ensemble ne soit pas fixe, il peut inclure une variété d'éléments. Un avantage clé de l'utilisation des ensembles par rapport aux listes est leur méthode hautement efficace pour déterminer si un élément existe dans l'ensemble.

Travail avec des Listes Imbriquées en Python

Utilisation de variables pour les listes imbriquées

Solution