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.

Al trabajar con listas grandes o complejas, a menudo es útil saber cuántos elementos contienen. Python proporciona la función `len()`, que devuelve el número total de elementos en una lista.

Una lista anidada se considera un solo elemento. La función `len()` no cuenta los elementos individuales dentro de una lista anidada como elementos separados de la lista principal.

Nota

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

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 set? En Python, un set es una colección desordenada que es tanto iterable como mutable, sin elementos repetidos. Aunque el orden de los elementos en un set no está definido, puede incluir una variedad de elementos. Un beneficio clave de usar sets en lugar de listas es su método altamente eficiente para determinar si un elemento existe dentro del set.

Medición y Gestión del Tamaño de Listas

Medición y Gestión del Tamaño de Listas

Solución