Python: obtener número de elementos en una lista

    Introducción

    Obtener la cantidad de elementos en una lista en Python es una operación común. Por ejemplo, necesitará saber cuántos elementos tiene la lista cada vez que la recorra. Recuerde que las listas pueden tener una combinación de enteros, flotantes, cadenas, valores booleanos, otras listas, etc.como sus elementos:

    # List of just integers
    list_a = [12, 5, 91, 18]
    
    # List of integers, floats, strings, booleans
    list_b = [4, 1.2, "hello world", True]
    

    Si contamos los elementos en list_a obtenemos 5 elementos en total. Si hacemos lo mismo por list_b obtendremos 4 elementos.

    Hay diferentes formas de obtener el número de elementos de una lista. Los enfoques varían si desea contar listas anidadas como un elemento o todos los elementos en las listas anidadas, o si solo está interesado en elementos únicos y similares.

    Función incorporada len ()

    La forma más sencilla de obtener la cantidad de elementos en una lista es usar la función incorporada de Python len().

    Veamos el siguiente ejemplo:

    list_a = ["Hello", 2, 15, "World", 34]
    
    number_of_elements = len(list_a)
    
    print("Number of elements in the list: ", number_of_elements)
    

    Que imprime:

    Number of elements in the list: 5
    

    Como sugiere la función de nombre, len() devuelve la longitud de la lista, independientemente de los tipos de elementos en ella.

    Usando un bucle for

    Otra forma en que podemos hacer esto es crear una función que recorra la lista usando un for lazo. Primero inicializamos el recuento de elementos a 0 y cada vez que se realiza una iteración de bucle, el recuento aumenta en 1.

    El ciclo finaliza cuando itera sobre todos los elementos, por lo tanto, el recuento representará el número total de elementos en la lista:

    list_c = [20, 8.9, "Hi", 0, "word", "name"]
    
    def get_number_of_elements(list):
        count = 0
        for element in list:
            count += 1
        return count
    
    print("Number of elements in the list: ", get_number_of_elements(list_c))
    

    Ejecutar este código imprimirá:

    Number of elements in the list:  6
    

    Esta es una solución mucho más detallada en comparación con la len() , pero vale la pena repasarlo, ya que veremos más adelante en el artículo que la misma idea se puede aplicar cuando se trata de una lista de listas. Además, es posible que desee realizar alguna operación en los elementos mismos o en una operación en general, lo cual es posible aquí.

    Obtener número de elementos únicos en una lista

    Las listas pueden tener varios elementos, incluidos los duplicados. Si queremos obtener la cantidad de elementos sin duplicados (elementos únicos) podemos usar otra función incorporada set(). Esta función crea una set objeto, que rechaza todos los valores duplicados.

    Luego pasamos eso al len() función para obtener el número de elementos en el set:

    list_d = [100, 3, 100, "c", 100, 7.9, "c", 15]
    
    number_of_elements = len(list_d)
    number_of_unique_elements = len(set(list_d))
    
    print("Number of elements in the list: ", number_of_elements)
    print("Number of unique elements in the list: ", number_of_unique_elements)
    

    Que imprime:

    Number of elements in the list: 8
    Number of unique elements in the list:  5
    

    Podemos ver eso list_d tiene un total de 8 elementos, de los cuales 5 son únicos.

    Lista de listas que utilizan len ()

    En la introducción, vimos que los elementos de las listas pueden ser de diferentes tipos de datos. Sin embargo, las listas pueden tener, a su vez, listas como elementos. Por ejemplo:

    list_e = [[90, 4, 12, 2], [], [34, 45, 2], [9,4], "char", [7, 3, 19]]
    

    Si usamos la función incorporada len(), las listas cuentan como elementos individuales, por lo que tendremos:

    number_of_elements = len(list_e)
    
    print("Number of elements in the list of lists: ", number_of_elements) 
    

    Que imprime:

    Number of elements in the list of lists: 6
    

    Tenga en cuenta que la lista vacía cuenta como un elemento. Si una lista dentro de una lista contiene más de un elemento, no se tienen en cuenta. Aquí es donde un for El bucle es útil.

    Obtener el número de elementos de una lista que contiene otras listas

    Si queremos contar todos los elementos dentro de una lista que contiene otras listas, podemos usar un for lazo. Podemos inicializar el count variable a 0 y recorrer la lista. En cada iteración de bucle, count aumenta por la longitud de esa lista.

    Usaremos la función incorporada len() para obtener la longitud:

    list_e = [[90, 4, 12, 2], [], [34, 45, 2], [9,4], "char", [7, 3, 19]]
    
    def get_all_elements_in_list_of_lists(list):
        count = 0
        for element in list_e:
            count += len(element)
        return count
    
    print("Total number of elements in the list of lists: ", get_all_elements_in_list_of_lists(list_e)) 
    

    La salida es:

    Total number of elements in the list of lists: 16
    

    Hay algunas cosas importantes a tener en cuenta en este ejemplo. En primer lugar, esta vez la lista vacía no afectó el recuento total. Esto se debe a que en cada ciclo consideramos la longitud de la lista anidada actual, y dado que la longitud de una lista vacía es 0, count aumenta en 0.

    Sin embargo, puede ver que todos los caracteres de la cadena "char" cuenta para el número total de elementos. Esto es porque el len() La función actúa sobre la cadena devolviendo todos sus caracteres. Podemos evitar esta situación utilizando el mismo enfoque que en la sección siguiente, que también nos permitiría tener elementos distintos a las listas.

    Otra forma divertida de hacer lo mismo que en el ejemplo anterior es mediante la comprensión de listas:

    number_of_elements = sum([len(element) for element in list_e])
    

    Esta línea esencialmente hace dos cosas. Primero, crea una nueva lista que contiene las longitudes de todos los elementos de la lista original. En nuestro caso eso sería [4, 0, 3, 2, 4, 3]. En segundo lugar, llama al sum() función usando la lista recién generada como parámetro, que devuelve la suma total de todos los elementos, dándonos el resultado deseado.

    Listas anidadas

    Las listas anidadas son listas que son elementos de otras listas. Puede haber varios niveles de listas una dentro de la otra:

    list_f = [30, 0.9, [8, 56, 22, ["a", "b"]], [200, 3, [5, [89], 10]]]
    

    Podemos ver eso ["a", "b"] está contenido en la lista [8, 56, 22, ["a", "b"]], que, a su vez, está contenido en la lista principal [30, 0.9,[200, 3, [5, [89], 10]]].

    Nuevamente, inicializamos el count variable a 0. Si queremos obtener el número total de elementos en la lista anidada, primero debemos verificar si el elemento es una lista o no. Si es así, hacemos un bucle dentro de la lista y llamamos recursivamente a la función hasta que no queden listas anidadas. Todos los elementos que no sean listas (números enteros, cadenas, etc.) aumentarán la cuenta en 1.

    Tenga en cuenta que esta también es la solución a los problemas causados ​​por el enfoque anterior.

    Echemos un vistazo al código para contar elementos en listas anidadas:

    list_f = [30, 0.9, [8, 56, 22, ["a", "hello"]], [200, 3, [5, [89], 10]]]
    
    def get_elements_of_nested_list(element):
        count = 0
        if isinstance(element, list):
            for each_element in element:
                count += get_elements_of_nested_list(each_element)
        else:
            count += 1
        return count
    
    print("Total number of elements in the nested list: ", get_elements_of_nested_list(list_f))
    

    Ejecutar este código nos daría:

    Total number of elements in the nested list: 12
    

    Tenga en cuenta que usamos la función incorporada isinstance() que comprueba si el primer argumento es una instancia de la clase dada como segundo argumento. En la función anterior, verifica si el elemento es una lista.

    El primer elemento 30 es un número entero, por lo que la función salta al else bloque y aumenta la cuenta en 1. Cuando llegamos a [8, 56, 22, ["a", "hello"]], la función reconoce una lista y la recorre de forma recursiva para buscar otras listas.

    Conclusión

    Vimos que según el tipo de lista que tengamos, existen diferentes formas de obtener la cantidad de elementos. len() es definitivamente la función más rápida y sencilla si tenemos listas planas.

    Con listas de listas y listas anidadas, len() no contará los elementos dentro de las listas. Para hacer eso, necesitamos recorrer toda la lista.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *