Summary  
This chapter explains how to use Python’s built-in len() function to measure the number of elements in a list—only counting top-level items and treating any nested list as a single element—and demonstrates printing that result.  

General domain of usage  
Data manipulation

In this video, you'll learn how to measure and manage the size of lists in Python using the `len()` function. You'll see that `len()` returns the number of items in a list, and that any nested list counts as a single item, not as multiple items. Watch how the example code uses `len()` to count the elements in `cities_list`, which includes a nested list. You'll also get an overview of the interactive task, where you'll apply the `len()` function to find out how many cities are in the `travel_wishlist` list. This practical exercise will help you confidently use `len()` to measure list length 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.

Lorsqu'on travaille avec des listes volumineuses ou complexes, il est souvent utile de connaître le nombre d’éléments qu’elles contiennent. Python fournit la fonction `len()`, qui retourne le nombre total d’éléments dans une liste.

Une liste imbriquée est considérée comme un seul élément. La fonction `len()` ne compte pas les éléments individuels à l’intérieur d’une liste imbriquée comme des éléments distincts de la liste principale.

Remarque

cities_list = ["Tokyo", "New York", "Sydney", "Berlin", ["Paris", "France"]]

list_length = len(cities_list)

print(list_length)

import unittest
import re
import importlib

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_list_length_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'list_length'),
            "The variable `list_length` is declared.",
            "Expected `list_length` to be declared."
        )

    def test_list_length_is_defined_correctly(self):
        import user_code
        expected = len(user_code.travel_wishlist)
        actual = user_code.list_length
        _dynamic_test(
            self,
            actual == expected,
            f"The `list_length` value equals the length of `travel_wishlist` ({expected}).",
            f"Expected `list_length` to equal {expected}, but got {actual}."
        )

    def test_len_function_used(self):
        import user_code
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()

        _dynamic_test(
            self,
            re.search(r'len\\s*\\(', user_code_source),
            "The `len()` function is used.",
            "Expected the `len()` function to be used."
        )

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 défis de programmation réels.

Qu'est-ce qu'une liste ? Une liste est une collection ordonnée qui peut ê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 compréhensibles 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 très efficace pour déterminer si un élément existe dans l'ensemble.

Mesure et Gestion de la Taille des Listes

Solution