Python: obtener el número de elementos en una lista

En este artículo, veremos cómo obtener la cantidad de elementos en una lista en Python. Veremos ejemplos de obtención de todos los elementos, elementos únicos y elementos en listas anidadas.

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 recorre. Recuerda que las listas pueden tener como elementos una combinación de enteros, flotantes, cadenas, booleanos, otras listas, etc.:

1
2
3
4
5
# 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 con list_b obtendremos 4 elementos.

Hay diferentes formas de obtener el número de elementos en una lista. Los enfoques varían si desea contar las 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 integrada len()

La forma más directa de obtener el número de elementos en una lista es usar la función integrada de Python len().

Veamos el siguiente ejemplo:

1
2
3
4
5
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:

1
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 que contenga.

Usar un bucle for

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

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

1
2
3
4
5
6
7
8
9
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á:

1
Number of elements in the list:  6

Esta es una solución mucho más detallada en comparación con la función len(), pero vale la pena revisarla, ya que veremos más adelante en el artículo que la misma idea se puede aplicar cuando estamos tratando con 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í.

Obtenga el número de elementos únicos en una lista

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

Luego pasamos eso a la función len() para obtener el número de elementos en el conjunto:

1
2
3
4
5
6
7
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:

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

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

Lista de listas usando 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:

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

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

1
2
3
number_of_elements = len(list_e)

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

Que imprime:

1
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 bucle for resulta ú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 bucle for. Podemos inicializar la variable count a 0 y recorrer la lista. En cada iteración del bucle, count aumenta según la longitud de esa lista.

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

1
2
3
4
5
6
7
8
9
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:

1
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 se incrementa en 0.

Sin embargo, puede ver que cada carácter de la cadena "char" cuenta para el número total de elementos. Esto se debe a que la función len() actúa sobre la cadena devolviendo todos sus caracteres. Podemos evitar esta situación utilizando el mismo enfoque que en la sección a continuación, que también nos permitiría tener otros elementos además de las listas.

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

1
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 sería [4, 0, 3, 2, 4, 3]. En segundo lugar, llama a la función sum() utilizando 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 otra:

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

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

Nuevamente, inicializamos la variable count 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 (enteros, cadenas, etc.) aumentarán el conteo en 1.

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

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
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:

1
Total number of elements in the nested list: 12

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

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

Conclusión

Vimos que según el tipo de lista que tengamos, hay diferentes formas de obtener el número de elementos. len() es definitivamente la función más rápida y simple 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.