Pitone è un linguaggio di programmazione popolare e versatile, ma come qualsiasi altro linguaggio può generare errori il cui debug può essere frustrante. Uno degli errori più comuni riscontrati dagli sviluppatori è il file TypeError: l'oggetto 'NoneType' non è iterabile. In questo articolo esploreremo vari scenari in cui può verificarsi questo errore e forniremo soluzioni pratiche per aiutarti ad affrontarlo in modo efficace.
Comprensione dell'errore: l'oggetto NoneType non è iterabile
Il messaggio di errore TypeError: l'oggetto 'NoneType' non è iterabile In Pitone in genere si verifica quando si tenta di eseguire un'iterazione su un oggetto che ha un valore di Nessuno . Questo errore viene generato perché None non è iterabile, il che significa che non puoi scorrerlo come puoi con elenchi, tuple o altri oggetti iterabili.
sintassi: TypeError: l'oggetto 'NoneType' non è iterabile
Cause di TypeError: l'oggetto 'NoneType' non è iterabile
- Dichiarazione di reso mancante
- Risposta API non valida
- Iterazione su una variabile con il valore None
- Nessuno Errore di tipo nelle classi
- Funzioni Lambda ed errore NoneType
Dichiarazione di reso mancante
Uno degli scenari più comuni che portano a questo errore è la mancanza di un'istruzione return in una funzione. Diciamo che abbiamo una funzione che dovrebbe restituire a elenco di numeri, ma dimentichiamo di includere un'istruzione return:
Python3
def> generate_numbers():> >numbers>=> [>1>,>2>,>3>,>4>,>5>]> ># Missing return statement> result>=> generate_numbers()> for> num>in> result:> >print>(num)> |
>
>
Produzione
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) c:Userspractice.ipynb Cell 1 line 6 3 # Missing return statement 5 result = generate_numbers() ---->6 for num nel risultato: 7 print(num) TypeError: l'oggetto 'NoneType' non è iterabile>
In questo caso, ' generare_numeri()' non restituisce nulla, il che significa che restituisce None. Quando proviamo a ripetere il risultato, incontreremo il messaggio ' TipoErrore' perché non possiamo scorrere su None.
Soluzione: garantire un reso adeguato
Per correggere questo errore, assicurati che la nostra funzione restituisca il valore previsto. In questo esempio, dovremmo aggiungere un'istruzione return to 'genera_numeri()':
Python3
def> generate_numbers():> >numbers>=> [>1>,>2>,>3>,>4>,>5>]> >return> numbers> result>=> generate_numbers()> for> num>in> result:> >print>(num)> |
>
colori Java
>
Produzione
1 2 3 4 5>
Ora, generare_numeri() restituisce un elenco di numeri e l'errore viene risolto.
Risposta API non valida
Un altro scenario in cui potresti riscontrare questo errore è quando lavori con API . Diciamo che stiamo effettuando una richiesta API per recuperare i dati, ma l'API restituisce None invece dei dati previsti:
Python3
import> requests> def> fetch_data():> >response>=> requests.get(>' https://api.openweathermap.org/data '>)> >if> response.status_code>=>=> 200>:> >return> response.json()> >else>:> >return> None> data>=> fetch_data()> for> item>in> data:> >print>(item)> |
>
>
Produzione
python // operatore
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) c:Userspractice.ipynb Cell 2 line 11 8 return None 10 data = fetch_data() --->11 per l'elemento in data: 12 print(item) TypeError: l'oggetto 'NoneType' non è iterabile>
Se la API la richiesta fallisce o viene restituita Nessuno, otterremo un 'Erroretipo' quando si tenta di scorrere i dati.
Soluzione: controllare la risposta dell'API
Per gestire questa situazione, dovremmo controllare la risposta API prima di tentare di eseguirne l'iterazione. Ecco una versione migliorata del codice:
Python3
import> requests> def> fetch_data():> >response>=> requests.get(>' https://api.openweathermap.org/data '>)> >if> response.status_code>=>=> 200>:> >return> response.json()> >else>:> >return> [ ]> data>=> fetch_data()> for> item>in> data:> >print>(item)> |
>
>
Se il codice di stato non è 200, significa che si è verificato un problema con il file API richiesta. In questo caso, restituiamo una lista vuota [] come valore segnaposto invece di None. Restituire una lista vuota ci consente di evitare il 'NessunoTipo' errore durante il tentativo di scorrere i dati di risposta più avanti nel codice.
Iterazione su una variabile con il valore None
Questo scenario è semplice e comune. Si verifica quando proviamo a eseguire il loop (iterazione) su una variabile che ha il valore None:
Python3
my_list>=> None> for> item>in> my_list:> >print>(item)> |
>
>
Produzione
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) c:Userspractice.ipynb Cell 3 line 2 1 my_list = None ---->2 per l'elemento in my_list: 3 print(item) TypeError: l'oggetto 'NoneType' non è iterabile>
In questo scenario, la variabile ' la mia lista' è impostato su Nessuno. Quando il ciclo for tenta di ripetere l'iterazione 'la mia lista' , incontra il TypeError: l'oggetto 'NoneType' non è iterabile. Questo errore si verifica perché None non è un oggetto iterabile e non è possibile eseguirne il ciclo.
Soluzione: garantire la presenza Iterable prima del loop
Per correggere questo errore, dobbiamo assicurarcelo 'la mia lista' contiene un oggetto iterabile (come una lista, una tupla, ecc.) prima di tentare di scorrere su di esso. Aggiungendo un segno di spunta come se mia_lista non è Nessuno prima del ciclo garantisce che il codice all'interno del ciclo venga eseguito solo se la mia lista non è Nessuno, impedendo il 'NessunoTipo' errore.
Python3
my_list>=> None> if> my_list>is> not> None>:> >for> item>in> my_list:> >print>(item)> |
>
>
Nessuno Errore di tipo nelle classi
Classi In Pitone può anche incontrare 'NessunoTipo' errori, soprattutto quando si lavora con metodi che restituiscono None. Considera una classe con un metodo che non restituisce alcun valore.
Supponiamo di avere una classe denominata 'Alunno'. In questa classe, vogliamo memorizzare il nome di uno studente e i suoi voti. La classe ha un metodo chiamato 'get_grades()' che, logicamente, dovrebbe restituire i voti dello studente. In questa situazione, uno studente di nome ' Alisha' viene creato con un elenco di voti. L'intenzione è verificare se qualcuno dei voti di Alisha è superiore o uguale a 90 e stamparli
Ecco il codice iniziale:
Python3
class> Student:> >def> __init__(>self>, name,grade):> >self>.name>=> name> >self>.grade>=> grade> > >def> get_grades(>self>):> > >print>(>self>.grade)> > > student>=> Student(>'Alisha'>,[>90>,>85>,>88>,>92>])> for> grade>in> student.get_grades():> >if> grade>>=>90>:> >print>(grade)> |
conversione di una stringa in un numero intero
>
>
Produzione
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) c:Userspractice.ipynb Cell 4 line 13 8 print(self.grade) 11 student = Student('Alisha',[90,85,88,92]) --->13 per il voto in student.get_grades(): 14 if grade>=90: 15 print(grade) TypeError: L'oggetto 'NoneType' non è iterabile> La questione sta nel 'get_grades()' metodo. Sebbene stampi i voti, non li restituisce. Quando proviamo a eseguire il loop 'student.get_grades()' , stampa i voti ma non fornisce alcun valore con cui lavorare nel ciclo.
Quindi, quando proviamo a ripetere il risultato di 'student.get_grades()', ritorna implicitamente 'Nessuno' perché non esiste un'istruzione return esplicita nel file 'get_grades()' metodo. Pitone lo considera None, che non è iterabile. Di conseguenza, incontriamo a TypeError: l'oggetto 'NoneType' non è iterabile errore.
Soluzione: restituire valori appropriati dai metodi di classe
Per risolvere questo problema, dobbiamo modificare il file 'get_grades()' metodo. Invece di limitarsi a stampare i voti, dovrebbe restituirli. Restituire i voti significa fornire un elemento iterabile (in questo caso, l'elenco dei voti) al chiamante del metodo. Restituendo i voti, il metodo diventa iterabile e il ciclo può funzionare come previsto.
Python3
class> Student:> >def> __init__(>self>, name,grade):> >self>.name>=> name> >self>.grade>=> grade> > >def> get_grades(>self>):> > >return> self>.grade> > > student>=> Student(>'Alisha'>,[>90>,>85>,>88>,>92>])> for> grade>in> student.get_grades():> >if> grade>>=>90>:> >print>(grade)> |
>
>
Quindi in questo codice corretto, il 'get_grades()' il metodo restituisce ‘auto.voto’, che è l'elenco dei voti. Quando iteriamo 'student.get_grades()' , ripeteremo l'elenco dei voti e non ce ne sarà alcuno 'NessunoTipo' errore perché stiamo eseguendo l'iterazione su un oggetto iterabile valido.
Produzione
90 92>
Funzioni Lambda ed errore NoneType
L'errore TypeError: l'oggetto 'NoneType' non è iterabile può verificarsi in funzioni lambda quando la funzione lambda restituisce None in determinate situazioni. Ciò accade in genere quando restituiamo condizionalmente None per valori di input specifici. Quando proviamo a ripetere il risultato di una funzione lambda che restituisce None, riscontriamo questo errore.
Esempio: In questo esempio, se l'input X non è maggiore di 0 (x>0) , IL funzione lambda restituisce Nessuno. Quando proviamo a ripetere il risultato, stiamo provando a ripetere None, causando il file TypeError: l'oggetto 'NoneType' non è iterabile errore.
Python3
my_lambda>=> lambda> x: x>*> 2> if> x>>0> else> None> result>=> my_lambda(>->1>)> for> item>in> result:> >print>(item)> |
>
mappa hash Java
>
Produzione
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) c:Userspractice.ipynb Cell 5 line 3 1 my_lambda = lambda x: x * 2 if x>0 else Nessuno 2 risultato = my_lambda(-1) ----> 3 for elemento nel risultato: 4 print(elemento) TypeError: l'oggetto 'NoneType' non è iterabile>
Soluzione: garantire risultati iterabili
Per correggere questo errore, dovremmo gestire il caso in cui la funzione lambda restituisce None. Un modo per gestirlo è fornire un iterabile predefinito (come un elenco vuoto) nel caso di Nessuno. Ecco il codice corretto:
Python3
my_lambda>=> lambda> x: [x>*> 2>]>if> x>>0> else> []> result>=> my_lambda(>->1>)> for> item>in> result:> >print>(item)> |
>
>
Produzione: In questo codice fisso, il funzione lambda restituisce un elenco contenente x*2 Se 'X' è maggiore di 0. Se 'X' non è maggiore di 0 (come nel caso di -1), restituisce una lista vuota. Ora possiamo scorrere il risultato senza incontrare il file 'NessunoTipo' errore.