Nella programmazione Python, la comprensione e l’utilizzo efficace degli iterabili \u00e8 fondamentale per creare codice efficace. Gli iterabili sono oggetti attraverso i quali \u00e8 possibile iterare o creare un loop. Supportano lo scorrimento sequenziale degli elementi al loro interno, il che li rende uno strumento fondamentale per accedere e manipolare elementi in oggetti o strutture di dati.<\/p>\n
Questo articolo spiega come utilizzare correttamente gli iterabili in Python<\/a>, concentrandosi sui tipi di dati iterabili integrati nel linguaggio: liste, tuple, dizionari, stringhe e set. Inoltre, spiega come implementare tipi di iterabili personalizzati ed eseguire operazioni avanzate.<\/p>\n In Python, \u00e8 possibile iterare attraverso diversi tipi di iterabili utilizzando un ciclo La parola chiave Gli elenchi sono raccolte ordinate di elementi che consentono una facile iterazione con un ciclo Nel codice qui sopra, Le tuple sono simili alle liste ma sono immutabili. Si possono iterare proprio come le liste.<\/p>\n In questo esempio, il ciclo I set sono raccolte non ordinate di elementi unici. Si possono scorrere utilizzando un ciclo In questo esempio, il ciclo Le stringhe sono sequenze di caratteri che si possono scorrere carattere per carattere.<\/p>\n Il codice qui sopra itera la stringa “Kinsta” e stampa ogni carattere su una nuova riga. In ogni iterazione, la variabile L’utilizzo del ciclo Il codice precedente definisce un dizionario chiamato Nel codice qui sopra, Il codice qui sopra mostra come iterare sia le chiavi che i valori del dizionario Un altro modo per iterare su iterabili in Python restituendo sia l’indice che il valore corrispondente degli elementi \u00e8 la funzione Ecco l’output:<\/p>\n La funzione Ecco l’output:<\/p>\n Notiamo che, sebbene questo esempio specifichi l’indice iniziale dell’enumerazione, I generatori sono speciali iterabili Python che permettono di costruire oggetti generatori senza creare esplicitamente tipi incorporati come liste, set o dizionari. Possiamo usare i generatori per produrre valori man mano in base alla logica di generazione.<\/p>\n I generatori utilizzano l’istruzione Il codice fornito definisce una funzione Possiamo ottenere una maggiore concisione quando lavoriamo con le espressioni del generatore. Ad esempio, possiamo progettare una funzione generatore che incorpori anche la logica del ciclo:<\/p>\n In questo caso, assegniamo la variabile Python permette di personalizzare ulteriormente le operazioni iterabili utilizzando gli iteratori. Gli oggetti iteratore implementano il protocollo iteratore e contengono due metodi: In questo esempio, utilizziamo il metodo Gli iteratori personalizzati sono ideali per le operazioni che coinvolgono grandi insiemi di dati che non si possono caricare in memoria contemporaneamente. Poich\u00e9 la memoria \u00e8 costosa e soggetta a vincoli di spazio, possiamo usare un iteratore per elaborare gli elementi dei dati singolarmente senza caricare l’intero set di dati in memoria.<\/p>\n Python utilizza delle funzioni per spostarsi, manipolare e ispezionare gli elementi di una lista. Alcune funzioni comuni per gli elenchi sono:<\/p>\n L’esempio seguente mostra queste funzioni con un elenco:<\/p>\n Ecco l’output:<\/p>\n Nell’esempio precedente, la funzione Python offre funzioni avanzate che favoriscono la concisione delle operazioni iterabili. Di seguito ne elenchiamo alcune.<\/p>\n Le comprensioni di lista permettono di creare nuovi elenchi applicando una funzione a ciascun elemento degli elenchi esistenti. Ecco un esempio:<\/p>\n In questo frammento di codice, viene creata una lista chiamata Ecco l’output:<\/p>\n La funzione In questo esempio, Questo codice agisce come un sistema di valutazione per diversi frutti, con il primo elenco ( Un’altra funzione avanzata, filter, accetta due argomenti: una funzione e un iterabile. Applica la funzione a ogni elemento dell’iterabile e restituisce un nuovo iterabile contenente solo gli elementi per i quali la funzione restituisce un valore Nel codice qui sopra, iniziamo definendo una funzione, Come In questo codice, La funzione Ecco un esempio di come possiamo applicare la funzione Si ottiene il seguente risultato:<\/p>\n I casi limite sono comuni in molti scenari di programmazione e devono essere previsti negli iterabili. Esploriamo alcune possibilit\u00e0 che potremmo incontrare.<\/p>\n Potremmo incontrare dei problemi quando un iterabile \u00e8 vuoto, ma una logica di programmazione tenta di scorrerlo. Possiamo risolvere questo problema in modo programmatico per evitare inefficienze. Ecco un esempio che utilizza un’istruzione Questo \u00e8 il risultato:<\/p>\n Python supporta anche gli iterabili annidati, ovvero oggetti iterabili che contengono altri iterabili al loro interno. Ad esempio, possiamo avere un elenco di alimenti che contiene elenchi annidati di categorie di alimenti, come carne, verdure e cereali. Ecco come modellare uno scenario del genere utilizzando gli iterabili annidati:<\/p>\n Nel codice qui sopra, la variabile In Python, gli iterabili supportano anche operazioni di gestione delle eccezioni. Ad esempio, potremmo iterare su una lista e incontrare un errore Nel codice qui sopra, l’iterabile Imparare a usare al meglio l’iterazione in Python \u00e8 fondamentale per ottenere un codice efficiente e leggibile. Comprendere i vari modi per iterare su diverse strutture di dati, utilizzare le comprensioni, i generatori e sfruttare le funzioni integrate vi render\u00e0 dei programmatori Python esperti.<\/p>\n Sia che si lavori con liste, dizionari, stringhe o oggetti personalizzati, sapere come usare e manipolare gli iterabili \u00e8 un’abilit\u00e0 indispensabile nella programmazione Python<\/a>.<\/p>\n Quando avrete finito di costruire la vostra applicazione Python e vorrete ospitarla online, provate l’Come eseguire il loop degli iterabili in Python<\/h2>\n
for<\/code>. Ci\u00f2 permette di navigare in sequenze e di eseguire operazioni su singoli elementi all’interno di liste, set e dizionari.<\/p>\nfor<\/code> in Python si discosta dalla sua utilit\u00e0 in altri linguaggi orientati agli oggetti<\/a> come Java<\/a>. I loop di Python for<\/code> funzionano pi\u00f9 come i metodi degli iteratori<\/a>. Ecco alcuni esempi che dimostrano i loop negli iteratori:<\/p>\n1. Loop in una lista<\/h3>\n
for<\/code>.<\/p>\nfruits_list = [\"Apple\", \"Mango\", \"Peach\", \"Orange\", \"Banana\"]\n\nfor fruit in fruits_list:\n print(fruit)<\/code><\/pre>\nfruit<\/code> agisce come un iteratore che il ciclo utilizza per scorrere ogni elemento dell’elenco e contemporaneamente stamparlo. Il ciclo termina dopo aver valutato l’ultimo elemento dell’elenco. Il codice precedente dovrebbe dare il seguente risultato:<\/p>\nApple\nMango\nPeach\nOrange\nBanana<\/code><\/pre>\n2. Iterare una tupla<\/h3>\n
fruits_tuple = (\"Apple\", \"Mango\", \"Peach\", \"Orange\", \"Banana\")\n\nfor fruit in fruits_tuple:\n\tprint(fruit)<\/code><\/pre>\nfor<\/code> itera attraverso la tupla e ad ogni iterazione la variabile fruit<\/code> assume il valore dell’elemento corrente della tupla. Il codice dovrebbe dare il seguente risultato:<\/p>\nApple\nMango\nPeach\nOrange\nBanana<\/code><\/pre>\n3. Looping attraverso i set<\/h3>\n
for<\/code>.<\/p>\nfruits_set = {\"Apple\", \"Mango\", \"Peach\", \"Orange\", \"Banana\"}\n\nfor fruit in fruits_set:\n\tprint(fruit)<\/code><\/pre>\nfor<\/code> itera attraverso il set. Tuttavia, poich\u00e9 gli insiemi non sono ordinati, l’ordine di iterazione potrebbe non corrispondere all’ordine in cui gli elementi sono stati definiti nel set. In ogni iterazione, la variabile fruit<\/code> assume il valore dell’elemento corrente dell’insieme. Il codice dovrebbe dare un risultato simile al seguente (l’ordine pu\u00f2 variare):<\/p>\nMango\nBanana\nPeach\nApple\nOrange<\/code><\/pre>\n4. Iterazione di stringhe<\/h3>\n
string = \"Kinsta\"\n\nfor char in string:\n\tprint(char)<\/code><\/pre>\nchar<\/code> assume il valore del carattere corrente della stringa. Il codice dovrebbe dare il seguente risultato:<\/p>\nK\ni\nn\ns\nt\na<\/code><\/pre>\n5. Scorrimento di un dizionario<\/h3>\n
for<\/code> \u00e8 simile per liste, set, tuple e stringhe, ma \u00e8 diverso per i dizionari, che utilizzano coppie chiave-valore per memorizzare gli elementi. I dizionari rappresentano un caso unico per l’esecuzione del ciclo, in quanto \u00e8 possibile iterarli utilizzando approcci diversi. Ecco i diversi approcci che si possono utilizzare per scorrere un dizionario in Python:<\/p>\n\n
countries_capital = {\n \"USA\": \"Washington D.C.\",\n \"Australia\": \"Canberra\",\n \"France\": \"Paris\",\n \"Egypt\": \"Cairo\",\n \"Japan\": \"Tokyo\"\n}\n\nfor country in countries_capital.keys():\n print(country)<\/code><\/pre>\ncountries_capital<\/code>, dove i nomi dei paesi sono le chiavi e le rispettive capitali sono i valori. Il ciclo for<\/code> esegue l’iterazione delle chiavi del dizionario countries_capital<\/code> utilizzando il metodo keys()<\/code>. Questo metodo restituisce un oggetto vista che visualizza un elenco delle chiavi del dizionario, il che facilita l’esecuzione del ciclo su tutte le chiavi. Ad ogni iterazione, la variabile country<\/code> assume il valore della chiave corrente. Questo codice dovrebbe dare il seguente risultato:<\/p>\nUSA\nAustralia\nFrance\nEgypt\nJapan<\/code><\/pre>\n<\/li>\ncountries_capital = {\n \"USA\": \"Washington D.C.\",\n \"Australia\": \"Canberra\",\n \"France\": \"Paris\",\n \"Egypt\": \"Cairo\",\n \"Japan\": \"Tokyo\"\n}\n\nfor capital in countries_capital.values():\n print(capital)<\/code><\/pre>\nfor<\/code> itera i valori del dizionario countries_capital<\/code> utilizzando il metodo values()<\/code>. Questo metodo restituisce un oggetto vista che visualizza un elenco dei valori del dizionario, rendendo pi\u00f9 semplice l’iterazione di tutti i valori. Ad ogni iterazione, la variabile capital<\/code> assume il valore del valore corrente nell’elenco. Questo codice dovrebbe dare il seguente risultato:<\/p>\nWashington D.C.\nCanberra\nParis\nCairo\nTokyo<\/code><\/pre>\n<\/li>\ncountries_capital = {\n \"USA\": \"Washington D.C.\",\n \"Australia\": \"Canberra\",\n \"France\": \"Paris\",\n \"Egypt\": \"Cairo\",\n \"Japan\": \"Tokyo\"\n}\n\nfor country, capital in countries_capital.items():\n print(country, \":\", capital)<\/code><\/pre>\ncountries_capital<\/code> utilizzando il metodo items()<\/code>. Il metodo items()<\/code> restituisce un oggetto vista che visualizza un elenco di tuple chiave-valore del dizionario. Nel ciclo for<\/code>, ogni iterazione scompone una coppia chiave-valore dall’elemento corrente dell’elenco. Alle variabili country<\/code> e capital<\/code> vengono assegnati rispettivamente la chiave e il valore corrispondenti. Questo codice dovrebbe dare il seguente risultato:<\/p>\nUSA : Washington D.C.\nAustralia : Canberra\nFrance : Paris\nEgypt : Cairo\nJapan : Tokyo<\/code><\/pre>\n<\/li>\n<\/ul>\nIterazione avanzata con enumerate() in Python<\/h3>\n
enumerate()<\/code>. Diamo uno sguardo a questo esempio:<\/p>\nfruits_list = [\"Apple\", \"Mango\", \"Peach\", \"Orange\", \"Banana\"]\n\nfor index, fruit in enumerate(fruits_list):\n print(fruit, index)<\/code><\/pre>\nApple 0\nMango 1\nPeach 2\nOrange 3\nBanana 4<\/code><\/pre>\nenumerate<\/code> permette anche di specificare l’indice iniziale, oltre a 0<\/code>, per l’operazione di iterazione. Possiamo modificare l’esempio precedente come segue:<\/p>\nfruits_list = [\"Apple\", \"Mango\", \"Peach\", \"Orange\", \"Banana\"]\nfor index, fruit in enumerate(fruits_list, start = 2):\n print(fruit, index)\n<\/code><\/pre>\nApple 2\nMango 3\nPeach 4\nOrange 5\nBanana 6<\/code><\/pre>\nenumerate<\/code> non applica un’indicizzazione a base zero all’iterabile, come avviene con le liste native. Applica semplicemente il valore iniziale al primo elemento dell’elenco fino all’ultimo.<\/p>\nCome implementare i generatori Python<\/h2>\n
yield<\/code> per restituire i valori generati uno alla volta. Ecco un esempio di generatori iterabili:<\/p>\ndef even_generator(n):\n counter = 0\n while counter <= n:\n if counter % 2 == 0:\n yield counter\n counter += 1\n\nfor num in even_generator(20):\n print(num)<\/code><\/pre>\neven_generator<\/code> che produce una sequenza di numeri pari da 0<\/code> a un n<\/code> specificato utilizzando l’istruzione yield<\/code>. Utilizza un ciclo per generare questi valori e itera il risultato utilizzando l’iteratore num<\/code>, assicurando la valutazione di tutti i valori all’interno dell’intervallo indicato. Questo codice produce un elenco di numeri pari da 0<\/code> a 20<\/code>, come mostrato di seguito:<\/p>\n0\n2\n4\n6\n8\n10\n12\n14\n16\n18\n20<\/code><\/pre>\ncube = (num ** 3 for num in range(1, 6))\nfor c in cube:\n print(c)<\/code><\/pre>\ncube<\/code> al risultato di una funzione che calcola il cubo dei valori compresi nell’intervallo da 1 a 6. La funzione \u00e8 in grado di generare un ciclo di valori all’interno dell’intervallo specificato. La funzione esegue poi un ciclo di valori all’interno dell’intervallo specificato, producendo i risultati del calcolo uno dopo l’altro. L’output \u00e8 il seguente:<\/p>\n1\n8\n27\n64\n125<\/code><\/pre>\nCome costruire iterabili personalizzati<\/h2>\n
__iter__()<\/code> e __next__()<\/code>. Il metodo __iter__()<\/code> restituisce un oggetto iteratore, mentre __next__()<\/code> restituisce il valore successivo in un contenitore iterabile. Ecco un esempio di iteratori in Python:<\/p>\neven_list = [2, 4, 6, 8, 10]\nmy_iterator = iter(even_list)\nprint(next(my_iterator)) # Prints 2\nprint(next(my_iterator)) # Prints 4\nprint(next(my_iterator)) # Prints 6<\/code><\/pre>\niter()<\/code> per creare un oggetto iteratore (my_iterator<\/code>) dall’elenco. Per accedere a ciascun elemento dell’elenco, avvolgiamo l’oggetto iteratore con il metodo next()<\/code>. Poich\u00e9 gli elenchi sono collezioni ordinate, l’iteratore restituisce gli elementi in sequenza.<\/p>\nFunzioni iterabili<\/h2>\n
\n
sum<\/code> – restituisce la somma di un dato iterabile, a condizione che l’insieme sia di tipo numerico (numeri interi, valori in virgola mobile e numeri complessi)<\/li>\nany<\/code> – restituisce true<\/code> se uno qualsiasi degli elementi dell’iterabile \u00e8 vero. Altrimenti, restituisce false<\/code>.<\/li>\nall<\/code> – restituisce true<\/code> se tutti gli elementi dell’iterabile sono veri. Altrimenti, restituisce false<\/code>.<\/li>\nmax<\/code> – restituisce il valore massimo di un dato insieme iterabile<\/li>\nmin<\/code> – restituisce il valore minimo di un dato insieme iterabile<\/li>\nlen<\/code> – restituisce la lunghezza di un dato iterabile<\/li>\nappend<\/code> – aggiunge un valore alla fine di un elenco iterabile<\/li>\n<\/ul>\neven_list = [2, 4, 6, 8, 10]\n\nprint(sum(even_list))\nprint(any(even_list))\nprint(max(even_list))\nprint(min(even_list))\neven_list.append(14) # Add 14 to the end of the list\nprint(even_list)\neven_list.insert(0, 0) # Insert 0 and specified index [0]\nprint(even_list)\nprint(all(even_list)) # Return true only if ALL elements in the list are true\nprint(len(even_list)) # Print the size of the list<\/code><\/pre>\n30\nTrue\n10\n2\n[2, 4, 6, 8, 10, 14]\n[0, 2, 4, 6, 8, 10, 14]\nFalse\n7<\/code><\/pre>\nappend<\/code> aggiunge un singolo parametro (14<\/code>) alla fine dell’elenco. La funzione insert<\/code> permette di specificare l’indice di inserimento. Pertanto, even_list.insert(0, 0)<\/code> inserisce 0<\/code> all’indice [0]<\/code>.
\nL’istruzione print(all(even_list))<\/code> restituisce false<\/code> perch\u00e9 nell’elenco \u00e8 presente un valore 0<\/code>, interpretato come false<\/code>. Infine, print(len(even_list))<\/code> restituisce la lunghezza dell’iterabile.<\/p>\nOperazioni iterabili avanzate<\/h2>\n
1. Comprensioni di lista<\/h3>\n
my_numbers = [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]\neven_number_list = [num for num in my_numbers if num%2 == 0]\nprint(even_number_list)<\/code><\/pre>\nmy_numbers<\/code> con i numeri interi da 11<\/code> a 20<\/code>. L’obiettivo \u00e8 quello di generare una nuova lista, even_number_list<\/code>, contenente solo numeri interi pari. Per raggiungere questo obiettivo, si applica una comprensione della lista che restituisce un intero da my_numbers<\/code> solo se quell’intero \u00e8 pari. L’istruzione if<\/code> contiene la logica che restituisce i numeri pari.<\/p>\n[12, 14, 16, 18, 20]<\/code><\/pre>\n2. Zip<\/h3>\n
zip()<\/code> di Python combina pi\u00f9 iterabili in tuple. Le tuple memorizzano pi\u00f9 valori in un’unica variabile e sono immutabili. Ecco come combinare gli iterabili usando zip()<\/code>:<\/p>\nfruits = [\"apple\", \"orange\", \"banana\"]\nrating = [1, 2, 3]\n\nfruits_rating = zip(rating, fruits)\nprint(list(fruits_rating))<\/code><\/pre>\nfruits_rating<\/code> accoppia ogni valutazione con un frutto, creando un unico iterabile. L’output \u00e8:<\/p>\n[(1, 'apple'), (2, 'orange'), (3, 'banana')]<\/code><\/pre>\nfruits<\/code>) che rappresenta i frutti e il secondo elenco che rappresenta le valutazioni su una scala da 1 a 3.<\/p>\n3. Filter<\/h3>\n
true<\/code>. L’esempio seguente filtra un elenco di valori interi all’interno di un determinato intervallo per restituire solo quelli pari:<\/p>\ndef is_even(n):\n return n%2 == 0\n\nnums_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\neven_list = filter(is_even, nums_list)\nprint(list(even_list))<\/code><\/pre>\nis_even<\/code>, per calcolare un numero pari passato a tale funzione. Poi, creiamo un elenco di valori interi compresi tra 1 e 10 – nums_list<\/code>. Infine, definiamo una nuova lista, even_list<\/code>, che utilizza la funzione filter()<\/code> per applicare il metodo definito dall’utente alla lista originale e restituire solo gli elementi della lista pari. Ecco il risultato:<\/p>\n[2, 4, 6, 8, 10]<\/code><\/pre>\n4. Map<\/h3>\n
filter()<\/code>, la funzione map()<\/code> di Python prende come argomenti un’iterabile e una funzione. Ma invece di restituire gli elementi dell’iterabile iniziale, restituisce una nuova iterabile contenente il risultato della funzione applicata a ciascun elemento della prima iterabile. Per elevare al quadrato un elenco di numeri interi, usiamo la funzione map()<\/code>:<\/p>\nmy_list = [2, 4, 6, 8, 10]\nsquare_numbers = map(lambda x: x ** 2, my_list)\nprint(list(square_numbers))<\/code><\/pre>\nx<\/code> \u00e8 l’iteratore che attraversa l’elenco e lo trasforma attraverso il calcolo del quadrato. La funzione map()<\/code> esegue questa operazione prendendo come argomento l’elenco originale e una funzione di mappatura. L’output \u00e8 il seguente:<\/p>\n[4, 16, 36, 64, 100]<\/code><\/pre>\n5. Sorted<\/h3>\n
sorted<\/code> ordina gli elementi di un dato iterabile in un ordine specifico (ascendente o discendente) e lo restituisce come elenco. Accetta un massimo di 3 parametri: iterable<\/code>, reverse<\/code>(opzionale) e key<\/code>(opzionale). reverse<\/code> ha come valore predefinito False<\/code> e, se impostato su True<\/code>, gli elementi vengono ordinati in ordine decrescente. key<\/code> \u00e8 una funzione che calcola un valore per determinare l’ordine degli elementi di un iterabile e ha come valore predefinito None<\/code>.<\/p>\nsorted<\/code> a diversi iterabili:<\/p>\n# set\npy_set = {'e', 'a', 'u', 'o', 'i'}\nprint(sorted(py_set, reverse=True))\n\n# dictionary\npy_dict = {'e': 1, 'a': 2, 'u': 3, 'o': 4, 'i': 5}\nprint(sorted(py_dict, reverse=True))\n\n# frozen set\nfrozen_set = frozenset(('e', 'a', 'u', 'o', 'i'))\nprint(sorted(frozen_set, reverse=True))\n\n# string\nstring = \"kinsta\"\nprint(sorted(string))\n\n# list\npy_list = ['a', 'e', 'i', 'o', 'u']\nprint(py_list)<\/code><\/pre>\n['u', 'o', 'i', 'e', 'a']\n['u', 'o', 'i', 'e', 'a']\n['u', 'o', 'i', 'e', 'a']\n['a', 'i', 'k', 'n', 's', 't']\n['a', 'e', 'i', 'o', 'u']<\/code><\/pre>\nCome gestire i casi limite e gli errori negli iterabili<\/h2>\n
1. Iterabili vuoti<\/h3>\n
if not<\/code> per verificare se un elenco \u00e8 vuoto:<\/p>\nfruits_list=[]\nif not fruits_list:\n print(\"The list is empty\")<\/code><\/pre>\nThe list is empty<\/code><\/pre>\n2. Iterabili annidati<\/h3>\n
food_list = [[\"kale\", \"broccoli\", \"ginger\"], [\"beef\", \"chicken\", \"tuna\"], [\"barley\", \"oats\", \"corn\"]]\nfor inner_list in food_list:\n for food in inner_list:\n print(food)<\/code><\/pre>\nfood_list<\/code> contiene tre elenchi annidati, che rappresentano diverse categorie di alimenti. Il ciclo esterno (for inner_list in food_list:<\/code>) itera attraverso l’elenco primario e il ciclo interno (for food in inner_list:<\/code>) itera attraverso ogni elenco annidato, stampando ogni alimento. L’output \u00e8 il seguente:<\/p>\nkale\nbroccoli\nginger\nbeef\nchicken\ntuna\nbarley\noats\ncorn<\/code><\/pre>\n3. Gestione delle eccezioni<\/h3>\n
IndexError<\/code>. Questo errore significa che stiamo cercando di fare riferimento a un elemento che supera i limiti dell’iterabile. Ecco come gestire un’eccezione di questo tipo utilizzando un blocco try-except<\/code>:<\/p>\nfruits_list = [\"apple\", \"mango\", \"orange\", \"pear\"]\ntry:\n print(fruits_list[5])\nexcept IndexError:\n print(\"The index specified is out of range.\")<\/code><\/pre>\nfruits_list<\/code> contiene cinque elementi mappati dagli indici 0<\/code> e 5<\/code> nella collezione di liste. La frase try<\/code> contiene una funzione print<\/code> che tenta di visualizzare il valore all’indice 5<\/code> dell’iterabile, che non esiste. Viene eseguita la funzione except clause, returning the associated error message. The console returns the error:<\/code><\/code><\/p>\nThe index specified is out of range.<\/code><\/pre>\nRiepilogo<\/h2>\n