Dimensione delle liste in Python: 8 metodi diversi per trovare la lunghezza di una lista in Python

Le liste in Python sono una struttura dati fondamentale, essenziale per memorizzare e manipolare collezioni di elementi. La loro flessibilità e semplicità d’uso le rendono indispensabili in un’ampia gamma di attività di programmazione, dall’analisi dei dati allo sviluppo web. Dato il loro uso diffuso, un’esigenza comune è determinare la dimensione di una lista. Sebbene la funzione len() sia ampiamente conosciuta, la sintassi ricca di Python e il supporto della libreria offrono molti altri modi per ottenere questo risultato, ciascuno con le proprie sfumature e applicazioni. In questo articolo analizziamo otto di questi metodi, illustrandone il funzionamento e l’efficienza.

Perché le liste in Python sono importanti?

Le liste in Python sono array dinamici che possono contenere un mix di tipi di dato, offrendo uno strumento versatile per l’archiviazione e la manipolazione dei dati. Facilitano operazioni come l’iterazione, lo slicing e manipolazioni complete con metodi integrati come append(), remove() e sort(), tra gli altri. Puoi approfondire le manipolazioni delle liste in questo tutorial.

Come definire una lista in Python

Per gli scopi di questo tutorial, useremo una lista semplice per mostrare ciascun metodo. Considera la lista my_list, definita come segue:

# Define a sample list to be used throughout the tutorial
my_list = ["I", "Love", "Learning", "Python"]Offerto da

Questa lista, sebbene semplice, è perfetta per illustrare varie tecniche per determinarne la lunghezza.

8 modi per trovare la dimensione di una lista in Python

1. Trovare la dimensione di una lista usando la funzione len()

La funzione len() è l’approccio più diretto per determinare la dimensione di una lista. Non solo è concisa, ma anche molto efficiente, il che la rende il metodo di riferimento nella maggior parte dei casi.

# Use len() to find the size of the list
length = len(my_list)
print(length)  # Output: 4Offerto da

2. Trovare la dimensione di una lista usando un ciclo for

Conosciuto come metodo ingenuo, questo approccio prevede l’inizializzazione di un contatore e il suo incremento per ogni elemento incontrato in un ciclo for sulla lista. Puoi saperne di più sui cicli for e altri tipi di loop in questo tutorial.

# Naive method using a for loop to count the list's size
counter = 0
for item in my_list:
    counter += 1
print(counter)  # Output: 4Offerto da

3. Trovare la dimensione di una lista usando una list comprehension

Le list comprehension in Python offrono una sintassi compatta per eseguire operazioni su una lista. Qui la usiamo insieme alla funzione sum() per contare gli elementi.

# Using list comprehension to count the list's size
length = sum([1 for item in my_list])
print(length)  # Output: 4Offerto da

4. Trovare la dimensione di una lista usando reduce()

La funzione reduce() è un po’ più avanzata ma molto potente. Applica cumulativamente una funzione a due argomenti agli elementi di una lista, da sinistra a destra, in modo da ridurre la lista a un singolo valore. Nel nostro caso, la useremo per contare il numero di elementi in una lista.

Per semplificare la comprensione, la divideremo in due parti:

1. Definire una funzione semplice: per prima cosa definiamo una funzione semplice che prende due argomenti: il conteggio corrente (che chiameremo count_so_far) e un singolo elemento della lista (che chiameremo _ per indicare che non lo useremo davvero).
2. Usare reduce(): poi useremo reduce() per applicare questa funzione a ogni elemento della lista, contando di fatto gli elementi man mano che procede.

# Import the reduce function from the functools module
from functools import reduce

# Define a simple function to use with reduce
def update_count(count_so_far, _):
    """Increases the count by 1. The second parameter is not used."""
    return count_so_far + 1

# Use reduce to count the items in the list
# We start counting from 0, which is why we have '0' at the end
list_length = reduce(update_count, my_list, 0)

# Print out the result
print(list_length)  # Output will be 4Offerto da

5. Trovare la dimensione di una lista usando iter() e next()

Capire come contare gli elementi in una lista usando iter() e next() richiede di familiarizzare con gli iteratori. Un iteratore è un oggetto in Python che ci permette di scorrere tutti gli elementi di una lista uno alla volta. La funzione iter() trasforma una lista in un iteratore, e la funzione next() passa all’elemento successivo dell’iteratore.

Ecco la procedura passo passo:

1. Creare un iteratore: iniziamo trasformando la nostra lista in un iteratore usando la funzione iter(). Questo ci permette di attraversare la lista un elemento alla volta.
2. Contare usando un ciclo: impostiamo un ciclo che continuerà a funzionare finché non ci saranno più elementi nella lista. All’interno del ciclo, usiamo la funzione next() per passare all’elemento successivo della lista. Ogni volta che riusciamo a passare all’elemento successivo, aumentiamo il conteggio di 1.
3. Gestire la fine della lista: alla fine arriveremo alla fine della lista. Quando ciò accade, next() genera un errore StopIteration, indicando che non ci sono più elementi. Catturiamo questo errore con un blocco try/except e interrompiamo il conteggio.

Ecco il codice semplificato con commenti per aiutarti a capire ogni passaggio:

# Step 1: Turn the list into an iterator
list_iterator = iter(my_list)

# Initialize a counter to keep track of the number of items
count = 0

# Step 2: Loop through the list using the iterator
while True:
    try:
        # Use next() to get the next item from the iterator
        next(list_iterator)
        
        # If next() was successful, increase the count
        count += 1
    except StopIteration:
        # Step 3: If we reach the end of the list, break out of the loop
        break

# Print out the total count of items in the list
print(count)  # Output will be 4Offerto da

6. Trovare la dimensione di una lista usando enumerate()

La funzione enumerate() in Python aggiunge un contatore a un iterabile e lo restituisce sotto forma di oggetto enumerate. Questa funzione è comunemente usata nei cicli per ottenere sia l’indice sia il valore di ogni elemento della lista. Sebbene enumerate() non sia tipicamente usata per trovare la dimensione di una lista, possiamo utilizzarla per mostrare quanto Python sia flessibile.

# Step 1: Enumerate the list and convert it to a list of tuples (index, element)
enumerated_list = list(enumerate(my_list))

# Step 2: Extract the last tuple (which contains the last index and the last element)
last_tuple = enumerated_list[-1]

# Step 3: The size of the list is the last index plus 1 (because of zero-based indexing)
list_size = last_tuple[0] + 1

# Print out the size of the list
print(list_size)  # Output will be 4Offerto da

7. Trovare la dimensione di una lista usando NumPy

NumPy è una potente libreria Python ampiamente usata nel calcolo scientifico. Fornisce supporto per array e matrici di grandi dimensioni e multidimensionali, insieme a una raccolta di funzioni matematiche per operare su questi array. Per chi lavora con dati numerici, NumPy è uno strumento indispensabile, che offre archiviazione ed elaborazioni efficienti su dataset di grandi dimensioni. Per trovare la dimensione di una lista in Python usando NumPy, possiamo usare l’attributo .size come mostrato di seguito.

# Import the NumPy library
import numpy as np

# Step 1: Convert the list into a NumPy array
my_array = np.array(my_list)

# Step 2: Use the 'size' attribute of the NumPy array to find its size
array_size = my_array.size

# Print out the size of the array (which is the same as the length of the list)
print(array_size)  # Output will be 4Offerto da

8. Trovare la dimensione di una lista usando map() e sum()

Simile alla list comprehension, questo metodo usa map() per applicare una funzione che restituisce 1 per ogni elemento e, con sum(), aggrega poi questi valori per contare gli elementi. Questo metodo richiede familiarità con le funzioni lambda in Python. Per metterti al passo, dai un’occhiata a questo tutorial sulle lambda in Python.

# Using map() and sum() to count the list's size
length = sum(map(lambda x: 1, my_list))
print(length)  # Output: 4Offerto da

Confronto delle prestazioni dei diversi metodi per la dimensione delle liste in Python

Una cosa è conoscere tutti e otto i metodi per trovare la dimensione delle liste, un’altra è usare il metodo migliore. Per confrontare le prestazioni degli otto metodi discussi, useremo il modulo timeit di Python, che offre un modo semplice per misurare piccoli spezzoni di codice Python. Questo ci darà un’idea chiara di come ogni metodo si comporta in termini di velocità di esecuzione. Nota che i tempi di esecuzione possono variare in base alla tua macchina o all’ambiente in cui esegui il codice.

Impostazione dell’esperimento

Per semplificarci la vita, definiamo la nostra lista e le funzioni per ciascun metodo. Va bene anche se non hai familiarità con le funzioni; qui ci limitiamo a sistematizzare i diversi metodi per renderne più facile il confronto.

import timeit
from functools import reduce
import numpy as np

# Define the list
my_list = ["I", "Love", "Learning", "Python"] * 100  # Increased size for better statistical signifcance

# Method 1: Using len()
def method_len():
    return len(my_list)

# Method 2: Looping through the list
def method_loop():
    counter = 0
    for _ in my_list:
        counter += 1
    return counter

# Method 3: Using a list comprehension
def method_list_comprehension():
    return sum([1 for _ in my_list])

# Method 4: Using reduce()
def method_reduce():
    return reduce(lambda acc, _: acc + 1, my_list, 0)

# Method 5: Using iter() and next()
def method_iter_next():
    iterator = iter(my_list)
    counter = 0
    while True:
        try:
            next(iterator)
            counter += 1
        except StopIteration:
            break
    return counter

# Method 6: Using enumerate()
def method_enumerate():
    return max(enumerate(my_list, 1))[0]

# Method 7: Using numpy
def method_numpy():
    np_array = np.array(my_list)
    return np_array.size

# Method 8: Using map() and sum()
def method_map_sum():
    return sum(map(lambda _: 1, my_list))Offerto da

Misurare i tempi di ciascun metodo

A seguire, useremo timeit.timeit() per misurare i tempi di ciascuna funzione secondo l’ordine specificato:

# List to hold method names and their execution times
timing_results = []

methods = [method_len, method_loop, method_list_comprehension, method_reduce, 
           method_iter_next, method_enumerate, method_numpy, method_map_sum]

# Time each method
for method in methods:
 # Execute the operation 100000 times for better statistical significance  
    time_taken = timeit.timeit(method, number=100000)
    timing_results.append((method.__name__, time_taken))

# Sort results by time taken for better readability
timing_results.sort(key=lambda x: x[1])

# Print the timing results
for method_name, time_taken in timing_results:
    print(f"{method_name}: {time_taken:.5f} seconds")Offerto da

Eseguendo questo in DataLab, otteniamo i seguenti risultati:

Conclusione

In conclusione, questa esplorazione dei vari metodi per trovare la dimensione di una lista in Python ha messo in luce non solo la versatilità e la potenza di Python come linguaggio di programmazione, ma anche l’importanza di comprendere l’efficienza e l’applicabilità dei diversi approcci.

Per chi è agli inizi, è fondamentale partire dai metodi più semplici ed efficienti, come l’uso della funzione integrata len(), ottimizzata per prestazioni e leggibilità. Per saperne di più sul lavoro con le liste, dai un’occhiata alle seguenti risorse:

• Python Fundamentals skill track
• Introduction to Python course
• Python Cheat Sheet for Beginners