Come faccio a controllare se l'elenco è vuoto?
https://stackoverflow.com/questions/53513
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Se, per esempio, ha approvato la seguente:
a = []
Come posso controllare per vedere se a è vuota?
Soluzione
if not a:
print("List is empty")
Utilizzando il implicita booleanness di vuoto list è abbastanza divinatori.
Altri suggerimenti
Il divinatori modo per farlo è da PEP 8 guida di stile (dove Sì significa “raccomandato” e No significa “non raccomandato”):
Per le sequenze, (stringhe, liste, tuple), il fatto che sequenze vuote sono false.
Sì: if not seq: if seq: No: if len(seq): if not len(seq):
Io preferisco esplicitamente:
if len(li) == 0:
print('the list is empty')
In questo modo è chiaro al 100%, che li è una sequenza (elenco) e vogliamo testare la sua dimensione.Il mio problema con if not li: ... è che dà la falsa impressione che li è una variabile booleana.
Altre persone sembrano essere generalizzando la questione al di là solo le liste, così ho pensato di aggiungere un avvertimento per un diverso tipo di sequenza che un sacco di gente potrebbe utilizzare, soprattutto perché questo è il primo google ha colpito per "python test array vuoto".
Altri metodi non funzionano per gli array NumPy
È necessario essere attenti con array NumPy, perché altri metodi che funzionano bene per lists o altri contenitori standard fallire per array NumPy.Spiego il perché di seguito, in breve, il metodo preferito è quello di utilizzare size.
Il "divinatori" modo non funziona:Parte 1
Il "divinatori" fallisce con array NumPy perché NumPy prova a lanciare la matrice in una matrice di bools, e if x cerca di valutare tutte quelle bools in una sola volta per un qualche tipo di aggregazione valore di verità.Ma questo non ha alcun senso, così si ottiene un ValueError:
>>> x = numpy.array([0,1])
>>> if x: print("x")
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
Il "divinatori" modo non funziona:Parte 2
Ma almeno il caso di cui sopra ti dice che non è riuscito.Se vi capita di avere un NumPy array con un solo elemento, il if una dichiarazione di "lavoro", nel senso che non si ottiene un errore.Se, tuttavia, un elemento che sembra essere 0 (o 0.0, o False, ...), il if istruzione in modo non corretto risultato False:
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
Ma chiaramente x esiste e non è vuoto!Questo risultato non è quello voluto.
Utilizzando len possono dare risultati imprevisti
Per esempio,
len( numpy.zeros((1,0)) )
restituisce 1, anche se la matrice è zero elementi.
Il numpythonic modo
Come spiegato nel SciPy FAQ, il metodo corretto in tutti i casi in cui sai di avere un array NumPy è quello di utilizzare if x.size:
>>> x = numpy.array([0,1])
>>> if x.size: print("x")
x
>>> x = numpy.array([0,])
>>> if x.size: print("x")
... else: print("No x")
x
>>> x = numpy.zeros((1,0))
>>> if x.size: print("x")
... else: print("No x")
No x
Se non siete sicuri se si potrebbe essere un list, un array NumPy, o qualcosa d'altro, è possibile combinare questo approccio con la risposta @dubiousjim dà per assicurarsi il diritto di test è utilizzato per ogni tipo.Non molto "divinatori", ma si scopre che NumPy intenzionalmente rotto pythonicity almeno in questo senso.
Se avete bisogno di fare di più che semplicemente controllare se l'input è vuoto, e si utilizzano altre NumPy caratteristiche come l'indicizzazione o di operazioni matematiche, è probabilmente più efficiente (e certamente più comune) per forzare l'ingresso per essere un array NumPy.Ci sono un bel paio di funzioni per fare questo rapidamente, soprattutto numpy.asarray.Questo richiede il vostro input, non fa niente se è già un array, o avvolge il tuo ingresso in un array, se si tratta di un elenco, una tupla, ecc.... e, facoltativamente, converte la vostra scelta dtype.Quindi è molto veloce ogni volta che si può, e si assicura che si deve avere per assumere l'ingresso è un array NumPy.Noi di solito anche solo utilizzare lo stesso nome, come la conversione di un array non rendere di nuovo al di fuori della corrente ambito di applicazione:
x = numpy.asarray(x, dtype=numpy.double)
Questo renderà il x.size l'attività di controllo in tutti i casi mi vedi in questa pagina.
Modo migliore per controllare se l'elenco è vuoto
Se, per esempio, ha approvato la seguente:
a = []Come posso controllare per vedere se è vuoto?
Risposta Breve:
Posto la lista in un contesto booleano (per esempio, con un if o while istruzione).Si metterà alla prova False se è vuoto, e True altrimenti.Per esempio:
if not a: # do this!
print('a is an empty list')
Appello all'Autorità
PEP 8, l'ufficiale di Python guida di stile per il codice Python in Python standard library, afferma:
Per le sequenze, (stringhe, liste, tuple), il fatto che sequenze vuote sono false.
Yes: if not seq: if seq: No: if len(seq): if not len(seq):
Dobbiamo aspettarci che la libreria standard di codice dovrebbe essere il più performante e corretta possibile.Ma perché è che il caso, e perché abbiamo bisogno di questa guida?
Spiegazione
Mi capita spesso di vedere un codice come questo da parte di esperti programmatori Python:
if len(a) == 0: # Don't do this!
print('a is an empty list')
E gli utenti di lazy lingue può essere tentati di fare questo:
if a == []: # Don't do this!
print('a is an empty list')
Questi sono corretti nei loro rispettivi altre lingue.E questo è anche semanticamente corretto in Python.
Ma noi lo consideriamo un-Divinatori perché Python supporta questi semantica direttamente nell'elenco oggetto l'interfaccia di via boolean coercizione.
Dal docs (e si noti in particolare l'inclusione della lista vuota, []):
Per impostazione predefinita, un oggetto è considerato il vero a meno che la sua classe definisce un
__bool__()metodo che restituisceFalseo un__len__()metodo restituisce zero, quando è chiamato con l'oggetto.Qui ci sono la maggior parte degli oggetti incorporati considerate false:
- costanti definite false:
NoneeFalse.- zero di qualsiasi tipo numerico:
0,0.0,0j,Decimal(0),Fraction(0, 1)- sequenze vuote e collezioni:
'',(),[],{},set(),range(0)
E il datamodel documentazione:
Chiamato a realizzare il valore di verità di test e il built-in funzione
bool();dovrebbe tornareFalseoTrue.Quando questo metodo non è definito,__len__()si chiama, se è definito, e l'oggetto è considerata vera se il suo risultato è diverso da zero.Se una classe definisce né__len__()né__bool__(), tutte le sue istanze sono considerati veri e propri.
e
Chiamato a realizzare la funzione built-in
len().Deve restituire la lunghezza dell'oggetto, un numero intero >= 0.Inoltre, un oggetto che non definisce un__bool__()il metodo e la cui__len__()il metodo restituisce il valore zero è considerato falso in un contesto Booleano.
Così, invece di questo:
if len(a) == 0: # Don't do this!
print('a is an empty list')
o questo:
if a == []: # Don't do this!
print('a is an empty list')
Fare questo:
if not a:
print('a is an empty list')
Facendo la cosa Divinatori di solito paga in termini di prestazioni:
Fa pagare?(Si noti che meno tempo per eseguire un'operazione equivalente, è meglio:)
>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435
Per la bilancia, il costo della chiamata alla funzione e la costruzione e la restituzione di un elenco vuoto, che potrebbe sottrarre i costi di vuoto di verifica utilizzate in precedenza:
>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
Vediamo che sia il controllo per la lunghezza con la funzione builtin len rispetto al 0 o controllo contro una lista vuota è molto meno performante rispetto all'utilizzo di builtin sintassi del linguaggio documentato.
Perché?
Per il len(a) == 0 controllare:
Prima di Python ha il compito di controllare il globals per vedere se len è in ombra.
Quindi è necessario chiamare la funzione di carico 0, e fare il confronto di uguaglianza in Python (invece che con la "C"):
>>> import dis
>>> dis.dis(lambda: len([]) == 0)
1 0 LOAD_GLOBAL 0 (len)
2 BUILD_LIST 0
4 CALL_FUNCTION 1
6 LOAD_CONST 1 (0)
8 COMPARE_OP 2 (==)
10 RETURN_VALUE
E per il [] == [] si deve costruire un inutile elenco e poi, ancora, effettuare l'operazione di confronto in Python macchina virtuale (rispetto a C)
>>> dis.dis(lambda: [] == [])
1 0 BUILD_LIST 0
2 BUILD_LIST 0
4 COMPARE_OP 2 (==)
6 RETURN_VALUE
Il "Divinatori" modo è molto più semplice e più rapido controllo, in quanto la lunghezza della lista è memorizzato nell'oggetto dell'istanza di intestazione:
>>> dis.dis(lambda: not [])
1 0 BUILD_LIST 0
2 UNARY_NOT
4 RETURN_VALUE
Evidenza dalla sorgente C e la documentazione
Questa è un'estensione della
PyObjectche aggiunge laob_sizecampo.Questo è utilizzato solo per gli oggetti che hanno qualche nozione di lunghezza.Questo tipo spesso non vengono visualizzati nella Python/C API.Esso corrisponde ai campi definiti dall'espansione dellePyObject_VAR_HEADmacro.
Dalla sorgente c in Include/listobject.h:
typedef struct {
PyObject_VAR_HEAD
/* Vector of pointers to list elements. list[0] is ob_item[0], etc. */
PyObject **ob_item;
/* ob_item contains space for 'allocated' elements. The number
* currently in use is ob_size.
* Invariants:
* 0 <= ob_size <= allocated
* len(list) == ob_size
Ho goduto alla ricerca di questo e io spendere un sacco di tempo a curare le mie risposte.Se pensi che sto per lasciare qualcosa, per favore fatemelo sapere in un commento.
Una lista vuota è, di per sé considerate false in true test di valore (vedere documentazione di python):
a = []
if a:
print "not empty"
@Daren Thomas
EDIT:Un altro punto contro i test la lista vuota come False:Che dire polimorfismo?Non dovrebbe dipendere un elenco di un elenco.Si deve solo ciarlatano come un'anatra, - come stai andando per ottenere il vostro duckCollection di quack "False" quando non ha elementi?
Il duckCollection dovrebbe implementare __nonzero__ o __len__ così il se:funzionerà senza problemi.
Patrick (accettato) risposta è giusto: if not a: è il modo giusto per farlo. Harley Holcombe risposta è giusto che questo è il PEP 8 stile di guida.Ma quello che nessuno delle risposte spiegare è il motivo per cui è una buona idea di seguire l'idioma—anche se personalmente trovo che non è abbastanza esplicite o confusa Ruby utenti o qualsiasi altra cosa.
Codice Python e Python comunità è molto forte, i modi di dire.A seguito di tali idiomi rende il codice più facile da leggere per chiunque abbia esperienza in Python.E quando si violano tali idiomi, che è un segnale forte.
È vero che if not a: non distinguere elenchi vuoti da None, o numerico 0, o tuple vuote, vuote o creati dall'utente tipi di raccolta, o vuoti creati dall'utente non-abbastanza-tipi di raccolta, o di un singolo elemento di array NumPy agire come gli scalari con falsey valori, etc.E, a volte, è importante essere espliciti in tal senso.E in quel caso, sai cosa vuoi essere esplicito, quindi non è possibile verificare esattamente che.Per esempio, if not a and a is not None: significa "nulla falsey ad eccezione di Nessuno", mentre if len(a) != 0: significa "solo sequenze vuote—e nulla oltre una sequenza è un errore qui", e così via.Oltre alle prove di esattamente ciò che si desidera testare, questo segnala anche per il lettore che questo test è importante.
Ma quando non hai nulla per essere espliciti, altro che if not a: è fuorviante il lettore.Stai segnalazione di una cosa importante, quando non è così.(Si può anche rendere il codice meno flessibile o lento, o qualsiasi altra cosa, ma questo è meno importante.) E se si abitualmente indurre in errore il lettore come questo, quando si fare bisogno di fare una distinzione, che sta per passare inosservato perché non è stato "gridare al lupo" di tutto il codice.
Perché controllare a tutti?
Sembra che nessuno abbia affrontato mettendo in dubbio le tue bisogno per verificare l'elenco, in primo luogo.Perché hai fornito alcun ulteriore contesto, posso immaginare che potrebbe non essere necessario fare questo controllo, in primo luogo, ma non hanno familiarità con l'elaborazione di liste in Python.
Direi che il la maggior parte divinatori modo è quello di non controllare a tutti, ma solo la lista.Che modo è di fare la cosa giusta, vuota o piena.
a = []
for item in a:
<do something with item>
<rest of code>
Questo ha il vantaggio di gestire qualsiasi contenuto di un, mentre non necessitano di un controllo specifico per il vuoto.Se un è vuoto, il dipendente blocco non verrà eseguito e l'interprete sarà caduta la linea.
Se si fanno realmente bisogno di controllare l'array vuoto, le altre risposte sono sufficienti.
len() è un'operazione O(1) per Python liste, stringhe, dicts, e imposta.Python internamente tiene traccia del numero di elementi in questi contenitori.
JavaScript ha una simile nozione di truthy/falsy.
Avevo scritto:
if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff
che è stato votato -1.Non so se è perché i lettori contestato la strategia o pensato che la risposta non era utile come presentato.Farò finta che sia stato l'ultimo, poiché---qualunque cosa conta come "divinatori"---questa è la strategia corretta.A meno che non hai già escluso, o sono preparati a gestire i casi in cui a è, per esempio, False, è necessario un test più restrittive rispetto a solo if not a:.Si potrebbe usare qualcosa come questo:
if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
il primo test è in risposta a @Mike risposta di cui sopra.La terza linea potrebbe anche essere sostituito con:
elif isinstance(a, (list, tuple)) and not a:
se solo si desidera accettare le istanze di un particolare tipo (e relativi sottotipi), o con:
elif isinstance(a, (list, tuple)) and not len(a):
Si può ottenere via senza l'esplicito il tipo di controllo, ma solo se il contesto circostante, già si assicura che a è un valore dell'tipi siete preparati a gestire, o se siete sicuri che i tipi non siete preparati a gestire sta andando a generare errori (ad esempio, un TypeError se si chiama len su un valore per il quale esso non è definito) che siete pronti a gestire.In generale, il "divinatori" convenzioni sembrano andare in questo modo.Spremere come un'anatra e lasciarlo crescere un DuckError se non sai come ciarlatano.Si devono ancora pensare su che tipo di ipotesi che si stanno facendo, però, e se i casi non siete preparati a gestire correttamente davvero intenzione di un errore nei posti giusti.L'array Numpy sono un buon esempio in cui ciecamente affidamento su len o booleano typecast non può fare proprio ciò che ci si aspetta.
Da documentazione sul valore di verità di test:
Tutti i valori di diverso da ciò che è qui elencati sono considerati True
NoneFalse- zero di qualsiasi tipo numerico, per esempio,
0,0.0,0j. - qualsiasi sequenza vuota, per esempio,
'',(),[]. - qualsiasi vuoto di mappatura, per esempio,
{}. - le istanze delle classi definite dall'utente, se la classe definisce un
__bool__()o__len__()metodo, quando tale metodo restituisce un valore integer a zero o valore boolFalse.
Come potete vedere, la lista vuota [] è falsy, così facendo la cosa dovrebbe essere fatto per un valore booleano suoni più efficiente:
if not a:
print('"a" is empty!')
Qui ci sono alcuni modi si può controllare se l'elenco è vuoto:
a = [] #the list
1) Il abbastanza semplice divinatori modo:
if not a:
print("a is empty")
In Python, i contenitori vuoti come liste,tuple,set,dicts,variabili ecc sono visti come False.Si potrebbe semplicemente trattare l'elenco come un predicato (restituisce un valore Booleano).E un True valore indica che è non vuoto.
2) Molto esplicito:utilizzando il len() per trovare la lunghezza e controllare se è uguale a 0:
if len(a) == 0:
print("a is empty")
3) O il confronto ad un anonimo lista vuota:
if a == []:
print("a is empty")
4) Un altro ancora silly modo per farlo è utilizzando exception e iter():
try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")
Io preferisco il seguente:
if a == []:
print "The list is empty."
Metodo 1 (Consigliato):
if not a :
print ("Empty")
Metodo 2 :
if len(a) == 0 :
print( "Empty" )
Metodo 3:
if a == [] :
print ("Empty")
def list_test (L):
if L is None : print 'list is None'
elif not L : print 'list is empty'
else: print 'list has %d elements' % len(L)
list_test(None)
list_test([])
list_test([1,2,3])
A volte è buona per il test di None e per vuoto separatamente come quelli sono due stati diversi.Il codice di cui sopra produce il seguente output:
list is None
list is empty
list has 3 elements
Anche se vale la pena nulla di che None è falsy.Quindi, se non si vuole separare il test per None-ness, non hanno a che fare.
def list_test2 (L):
if not L : print 'list is empty'
else: print 'list has %d elements' % len(L)
list_test2(None)
list_test2([])
list_test2([1,2,3])
produce previsto
list is empty
list is empty
list has 3 elements
Molte risposte sono state date, e molti di loro sono abbastanza buone.Volevo solo aggiungere che il controllo
not a
anche passare per None e altri tipi di strutture vuote.Se veramente si vuole controllare una lista vuota, si può fare questo:
if isinstance(a, list) and len(a)==0:
print("Received an empty list")
Ispirato da @dubiousjim soluzione, propongo di utilizzare un ulteriore controllo generale se è qualcosa di iterable
import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)
Nota:una stringa è considerato iterable.- aggiungere and not isinstance(a,(str,unicode)) se si desidera che la stringa vuota per essere esclusi
Test:
>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True
Si può anche provare a utilizzare bool() come questo
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
Mi piace questo modo per controllare la lista è vuota o non.
Molto pratico e utile.
Modo più semplice è controllare la lunghezza è pari a zero.
if len(a) == 0:
print("a is empty")
print('not empty' if a else 'empty')
un po ' più pratico:
a.pop() if a else None
Da python3 in poi è possibile utilizzare
a == []
per controllare se la lista è vuota
EDIT :Questo funziona con python2.7 troppo..
Io non sono sicuro perché ci sono così tanti complicato risposte.È abbastanza chiaro e semplice
si può usare un semplice if else:
list=[]
if len(list)==0:
print ("list is empty")
else:
print ("list is not empty")
Semplicemente usare is_empty() o di rendere la funzione come:-
def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False
Può essere utilizzato per qualsiasi data_structure come una lista,tuple, dizionario e molti altri.Da questi, si può chiamare molte volte, utilizzando solo is_empty(any_structure).
Per verificare se la lista è vuota o non è possibile utilizzare due modi seguenti.Ma ricordate, si dovrebbe evitare di modo di modo esplicito il controllo di una sequenza o di un elenco (è un
less pythonicmodo):
def Enquiry(list1):
if len(list1) == 0:
return 0
else:
return 1
# ––––––––––––––––––––––––––––––––
list1 = []
if Enquiry(list1):
print ("The list isn't empty")
else:
print("The list is Empty")
# Result: "The list is Empty".
Il secondo modo è un
more pythonicuno.Questo metodo è un modo implicito di controllo e molto di più preferibile rispetto a quella precedente.
def Enquiry(list1):
if not list1:
return 1
else:
return 0
# ––––––––––––––––––––––––––––––––
list1 = []
if Enquiry(list1):
print ("The list is Empty")
else:
print ("The list isn't empty")
# Result: "The list is Empty"
Spero che questo aiuta.
Verificare se: len(list) == 0 restituisce: True
Se si desidera controllare se la lista è vuota;
l = []
if l:
# do your stuff.
Se si desidera controllare le previsioni del tempo tutti i valori nella lista è vuota.
l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
# do your stuff.
Tuttavia questo sarà Vero per la lista vuota.
def empty_list(lst):
if len(lst) ==0:
return false
else:
return all(bool(x) for x in l)
Ora è possibile utilizzare:
if empty_list(lst):
# do your stuff.
Il valore di verità di una lista vuota è False mentre per una lista non vuota è True.
Cosa mi ha portato qui è un particolare caso d'uso:Io in realtà volevo un funzione mi dica se l'elenco è vuoto o non.Volevo evitare di scrivere la mia funzione o l'utilizzo di un lambda-expression qui (perché sembrava che dovrebbe essere abbastanza semplice):
foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))
E, naturalmente, c'è un modo molto naturale per farlo:
foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))
Ovviamente, non non utilizzare bool in if (cioè, if bool(L): perché è implicita.Ma, per i casi in cui "non è vuoto" è esplicitamente necessaria in funzione, bool è la scelta migliore.
Un goffo modo di usare pop e try except clausola ((non raccomandata)):
a = []
try:
a.pop()
print('list isn\'t empty')
except:
print('list is empty')
Output:
list is empty
Una sorta di approccio :
a = []
try:
print(a[-1])
except IndexError:
print("List is empty")
