Comment puis-je vérifier si une liste est vide?
https://stackoverflow.com/questions/53513
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Par exemple, si elle est adoptée le suivant:
a = []
Comment puis-je vérifier pour voir si a est-il vide?
La solution
if not a:
print("List is empty")
À l'aide de l'implicite booleanness du vide list est tout à fait pythonic.
Autres conseils
Le pythonic façon de le faire c'est à partir de la PEP 8 guide de style (où Oui signifie “recommandé” et Pas de signifie “pas recommandé”):
Pour les séquences (chaînes de caractères, listes, tuples), utiliser le fait que les séquences vides sont fausses.
Oui: if not seq: if seq: Non: if len(seq): if not len(seq):
Je préfère explicitement:
if len(li) == 0:
print('the list is empty')
De cette façon, il est 100% clair que li est une séquence (liste) et nous voulons tester sa taille.Mon problème avec if not li: ... c'est qu'il donne la fausse impression que li est une variable booléenne.
D'autres personnes semblent être à la généralisation de la question au-delà des listes, donc, j'ai pensé ajouter une mise en garde pour un autre type de séquence que beaucoup de gens pourraient utiliser, en particulier puisque c'est la première google a frappé pour "python test tableau vide".
D'autres méthodes ne fonctionnent pas pour les tableaux NumPy
Vous devez être prudent avec les tableaux NumPy, parce que d'autres méthodes qui fonctionnent bien pour lists ou d'autres conteneurs standard échouer pour des tableaux NumPy.J'explique pourquoi ci-dessous, mais en bref, l' méthode préférée est d'utiliser size.
Le "pythonic" façon ne fonctionne pas:Partie 1
Le "pythonic" façon échoue avec NumPy tableaux parce que NumPy essaie de jeter le tableau d'un tableau de bools, et if x essaie d'évaluer l'ensemble de ces bools à la fois d'une sorte d'agrégat de valeur de vérité.Mais cela n'a aucun sens, de sorte que vous obtenez une 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()
Le "pythonic" façon ne fonctionne pas:Partie 2
Mais au moins le cas ci-dessus vous indique qu'il a échoué.Si vous avez un tableau NumPy avec un seul élément, l' if la déclaration de "travail", dans le sens que vous ne recevez pas un message d'erreur.Cependant, si un élément se trouve être 0 (ou 0.0, ou False, ...), la if déclaration incorrecte de résultat dans False:
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
Mais clairement x existe et n'est pas vide!Ce résultat n'est pas ce que tu voulais.
À l'aide de len peut donner des résultats inattendus
Par exemple,
len( numpy.zeros((1,0)) )
retourne 1, même si le tableau a zéro des éléments.
Le numpythonic façon
Comme expliqué dans l' SciPy FAQ, la méthode correcte dans tous les cas où vous savez que vous avez un tableau NumPy est d'utiliser 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
Si vous n'êtes pas sûr de savoir si elle pourrait être un list, un tableau NumPy, ou quelque chose d'autre, vous pouvez combiner cette approche avec la réponse @dubiousjim donne pour assurer que le bon test est utilisé pour chaque type.Pas très "pythonic", mais il s'avère que NumPy intentionnellement cassé pythonicity au moins dans ce sens.
Si vous avez besoin de faire plus que simplement vérifier si l'entrée est vide, et vous utilisez d'autres fonctions de NumPy comme l'indexation ou des opérations mathématiques, il est probablement plus efficace (et certainement plus commun) pour forcer l'entrée pour être un tableau NumPy.Il y a quelques belles fonctions pour le faire rapidement — le plus important numpy.asarray.Cela prend votre entrée, ne fait rien si c'est déjà un tableau, ou enveloppe votre entrée dans un tableau si c'est une liste, tuple, etc., et éventuellement convertit votre choix dtype.Il est donc très rapide à chaque fois qu'il peut être, et il s'assure que vous obtenez juste de supposer que l'entrée est un tableau NumPy.Nous avons l'habitude de même utiliser le même nom, comme la conversion d'un tableau ne sera pas de retour à l'extérieur de l'actuel portée:
x = numpy.asarray(x, dtype=numpy.double)
Cela rendra le x.size vérifier le travail dans tous les cas je vois sur cette page.
La meilleure façon de vérifier si une liste est vide
Par exemple, si elle est adoptée le suivant:
a = []Comment puis-je vérifier pour voir si a est vide?
Réponse Courte:
Place de la liste dans un contexte booléen (par exemple, avec un if ou while l'énoncé).Il permettra de tester False si elle est vide, et True sinon.Par exemple:
if not a: # do this!
print('a is an empty list')
Appel à l'Autorité
PEP 8, l'officiel de Python guide de style pour le code Python en Python standard library, affirme:
Pour les séquences (chaînes de caractères, listes, tuples), utiliser le fait que les séquences vides sont fausses.
Yes: if not seq: if seq: No: if len(seq): if not len(seq):
On devrait s'attendre à ce que la bibliothèque standard code doit être aussi performant et aussi correctes que possible.Mais pourquoi est-ce le cas, et pourquoi avons-nous besoin de cette orientation?
Explication
J'ai souvent voir ce type de code de l'expérience des programmeurs Python:
if len(a) == 0: # Don't do this!
print('a is an empty list')
Et les utilisateurs de paresseux langues peuvent être tentés de le faire:
if a == []: # Don't do this!
print('a is an empty list')
Ils sont corrects dans leurs autres langues.Et c'est même sémantiquement correct en Python.
Mais nous considérons qu'il est de l'onu-Pythonic parce que Python prend en charge ces sémantique directement dans la liste d'interface de l'objet via la contrainte de type boolean.
À partir de la docs (et notez spécifiquement l'inclusion de la liste vide, []):
Par défaut, un objet est considéré comme vrai, sauf si sa classe définit soit un
__bool__()méthode qui renvoieFalseou un__len__()méthode qui renvoie zéro, lorsqu'il est appelé avec l'objet.Voici la plupart des objets considérés comme de faux:
- les constantes définies fausse:
NoneetFalse.- zéro de tout type numérique:
0,0.0,0j,Decimal(0),Fraction(0, 1)- séquences vides et collections:
'',(),[],{},set(),range(0)
Et le modèle de données de la documentation:
Appelés à mettre en œuvre vérité le test de la valeur et de l'exploitation intégré
bool();doit retournerFalseouTrue.Lorsque cette méthode n'est pas définie,__len__()est appelée, si elle est définie, et l'objet est considérée comme vraie si son résultat est différent de zéro.Si une classe ne définit ni les__len__()ni__bool__(), de toutes ses instances sont considérées comme étant vrai.
et
Appelés à mettre en œuvre la fonction intégrée
len().Doit retourner la longueur de l'objet, qui est un entier >= 0.Aussi, un objet qui n'est pas de définir un__bool__()méthode et dont__len__()la méthode retourne la valeur zéro est considéré comme faux dans un contexte Booléen.
Ainsi, au lieu de ceci:
if len(a) == 0: # Don't do this!
print('a is an empty list')
ou ceci:
if a == []: # Don't do this!
print('a is an empty list')
Faire cela:
if not a:
print('a is an empty list')
En faisant ce qui est Pythonic rapporte habituellement dans la performance:
Est-il rembourser?(À noter que moins de temps pour effectuer une opération équivalente est mieux:)
>>> 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
Pour l'échelle, voici le coût de l'appel de la fonction et de la construction et de revenir une liste vide, que l'on pourrait soustraire les coûts de la vacuité des contrôles utilisés:
>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
Nous voyons que soit la vérification de la longueur avec la fonction builtin len par rapport à 0 ou la vérification d'une liste vide est beaucoup moins performante que l'utilisation du cache de la syntaxe de la langue comme documenté.
Pourquoi?
Pour l' len(a) == 0 vérifier:
Première Python a plus qu'à vérifier la globals pour voir si len est dans l'ombre.
Ensuite, il doit appeler la fonction, la charge 0, et faire la comparaison d'égalité en Python (au lieu de 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
Et pour le [] == [] elle doit construire une inutiles de la liste, puis, à nouveau, faire l'opération de comparaison en Python de la machine virtuelle (par opposition à C)
>>> dis.dis(lambda: [] == [])
1 0 BUILD_LIST 0
2 BUILD_LIST 0
4 COMPARE_OP 2 (==)
6 RETURN_VALUE
Le "Pythonic" moyen est beaucoup plus simple et plus rapide vérification car la longueur de la liste est mis en cache dans l'instance de l'objet en-tête:
>>> dis.dis(lambda: not [])
1 0 BUILD_LIST 0
2 UNARY_NOT
4 RETURN_VALUE
La preuve de la C source et de la documentation
C'est une extension de
PyObjectqui ajoute leob_sizechamp.Ce n'est utilisé que pour les objets qui ont une certaine idée de la longueur.Ce type n'apparaissent souvent dans le Python/C de l'API.Il correspond à la champs définis par l'expansion de laPyObject_VAR_HEADmacro.
À partir de la source c dans Inclure/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
J'ai apprécié la recherche de ce et je passe beaucoup de temps commissariat de mes réponses.Si vous pensez que je pars de quelque chose, s'il vous plaît laissez-moi savoir dans un commentaire.
Une liste vide est lui-même considéré comme faux dans le vrai test de la valeur (voir la documentation python):
a = []
if a:
print "not empty"
@Thomas Daren
EDIT:Un autre point contre les tests la liste vide comme Fausse:Ce sujet le polymorphisme?Vous ne devez pas dépendre de une liste une liste.Il faut juste charlatans comme un canard - comment allez-vous pour obtenir votre duckCollection aux charlatans "Faux" quand il n'a pas d'éléments?
Votre duckCollection devrait mettre en œuvre __nonzero__ ou __len__ donc la si:fonctionne sans problèmes.
Patrick (accepté) répondre est droit: if not a: est la bonne façon de le faire. Harley Holcombe réponse est juste que c'est dans la PEP 8 guide de style.Mais ce qu'aucune des réponses expliquer, c'est pourquoi il est une bonne idée de suivre l'idiome—même si vous trouve personnellement ce n'est pas assez explicite ou source de confusion pour Ruby utilisateurs ou quoi que ce soit.
Le code Python, et le Python de la communauté, a de très fortes expressions idiomatiques.A la suite de ces idiomes rend votre code plus facile à lire pour quelqu'un d'expérimenté en Python.Et si vous la violez ces idiomes, c'est un signal fort.
Il est vrai que if not a: ne fait pas la distinction vide listes de None, ou numérique 0 ou vide de n-uplets, ou le vide créé par l'utilisateur, les types de collection, ou vide créé par l'utilisateur, pas tout à fait la collection de types, ou à un seul élément d'un tableau NumPy agissant comme des scalaires avec falsey valeurs, etc.Et parfois, il est important d'être explicite à ce sujet.Et dans ce cas, vous savez ce vous voulez être explicite au sujet, de sorte que vous pouvez tester pour exactement que.Par exemple, if not a and a is not None: signifie "n'importe quoi falsey exception Aucune", tandis que if len(a) != 0: signifie "vide—séquences et autre chose qu'une séquence est une erreur", et ainsi de suite.En plus des tests pour exactement ce que vous voulez tester, cela a aussi des signaux au lecteur que ce test est important.
Mais quand vous n'avez pas de quoi être explicite sur, rien d'autre que if not a: est tromper le lecteur.Vous êtes à la signalisation de quelque chose d'aussi important quand il ne l'est pas.(Vous pouvez également vous rendre le code moins souple, ou plus lent, ou que ce soit, mais c'est moins important). Et si vous habituellement induire le lecteur en erreur comme cela, lorsque vous faire besoin de faire une distinction, il va passer inaperçu parce que vous avez été "crier au loup" partout dans votre code.
Pourquoi le contrôle à tout?
Personne ne semble avoir adressé votre questionnement besoin pour tester la liste de la première place.Parce que vous avez fourni aucune autre contexte, j'imagine que vous ne pouvez pas besoin de faire cette vérification dans la première place, mais ne sont pas familiers avec le traitement de liste en Python.
Je dirais que l' la plupart des pythonic façon de ne pas vérifier, mais plutôt de simplement le processus de la liste.De cette façon, il va faire la bonne chose, si vide ou plein.
a = []
for item in a:
<do something with item>
<rest of code>
Cela a l'avantage de gérer tout le contenu de un, bien que ne nécessitant pas un chèque spécifique pour le vide.Si un est vide, la charge de bloc sera pas exécuté et l'interprète de l'automne jusqu'à la ligne suivante.
Si vous n'avez réellement besoin de vérifier le tableau de vide, d'autres réponses sont suffisantes.
len() est un O(1) opérations de pour Python, les listes, les cordes, les dicts et ensembles.Python interne assure le suivi du nombre d'éléments dans ces conteneurs.
JavaScript a la même notion de truthy/falsy.
J'avais écrit:
if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff
ce qui a été voté à -1.Je ne sais pas si c'est parce que les lecteurs sont opposés à la stratégie ou de la pensée, la réponse n'était pas utile tel que présenté.Je vais faire semblant c'était le dernier, puisqu'---tout ce qui est considéré comme "pythonic"---c'est la bonne stratégie.Sauf si vous avez déjà écarté, ou sont préparés à gérer les cas où a est, par exemple, False, vous avez besoin d'un test plus restrictive que juste if not a:.Vous pouvez utiliser quelque chose comme ceci:
if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
le premier test est en réponse à @réponse de Mike, ci-dessus.La troisième ligne pourrait également être remplacé par:
elif isinstance(a, (list, tuple)) and not a:
si vous ne voulez accepter les instances de types particuliers (et leurs sous-types), ou avec:
elif isinstance(a, (list, tuple)) and not len(a):
Vous pouvez vous en sortir sans l'accord de vérification de type, mais seulement si le contexte environnant déjà vous assure que a est une valeur de types que vous êtes prêt à gérer, ou si vous êtes sûr que les types que vous n'êtes pas préparé à gérer vont faire des erreurs (par exemple, un TypeError si vous appelez len sur une valeur pour laquelle il est undefined) que vous êtes prêt à gérer.En général, le "pythonic" conventions semblent aller dans cette dernière manière.De le presser comme un canard et laisser lever une DuckError si elle ne sait pas comment charlatan.Vous avez encore de pense sur ce type d'hypothèses que vous faites, cependant, et si le cas, vous n'êtes pas préparé à gérer correctement vraiment allez erreur dans les bons endroits.Les tableaux Numpy sont un bon exemple où un peu à l'aveuglette en s'appuyant sur len ou le booléen transtypage peut pas faire précisément ce que vous attendez.
À partir de la documentation sur la valeur de vérité de test:
Toutes les valeurs autres que celles énumérées ici sont considérés comme des True
NoneFalse- zéro de tout type numérique, par exemple,
0,0.0,0j. - toute séquence vide, par exemple,
'',(),[]. - tout vide de cartographie, par exemple,
{}. - les instances de classes définies par l'utilisateur, si la classe définit un
__bool__()ou__len__()méthode, lorsque cette méthode renvoie le nombre entier zéro ou une valeur booléenneFalse.
Comme on le voit, la liste est vide [] est falsy, afin de faire ce qui serait fait en une valeur booléenne semble le plus efficace:
if not a:
print('"a" is empty!')
Voici quelques façons dont vous pouvez vérifier si une liste est vide:
a = [] #the list
1) La assez simple pythonic façon:
if not a:
print("a is empty")
En Python, les conteneurs vides comme les listes,les tuples,les décors,les dicts,variables, etc sont considérés comme des False.On pourrait simplement traiter la liste comme un prédicat (renvoyant une valeur Booléenne).Et un True valeur indiquerait qu'il est non-vide.
2) Un plus explicite:à l'aide de la len() pour trouver la longueur et de vérifier s'il est égal à 0:
if len(a) == 0:
print("a is empty")
3) Ou en le comparant à un anonyme liste vide:
if a == []:
print("a is empty")
4) Un autre encore idiot façon de le faire est d'utiliser exception et iter():
try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")
Je préfère le suivant:
if a == []:
print "The list is empty."
Méthode 1 (De Préférence):
if not a :
print ("Empty")
Méthode 2 :
if len(a) == 0 :
print( "Empty" )
Méthode 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])
Il est parfois bon de test pour None et pour le vide séparément que ceux sont deux états différents.Le code ci-dessus produit la sortie suivante:
list is None
list is empty
list has 3 elements
Bien qu'il ne vaut rien que None est falsy.Donc, si vous ne voulez pas de test spécifique pour None-ness, vous n'avez pas à le faire.
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])
produit attendu
list is empty
list is empty
list has 3 elements
Beaucoup de réponses ont été donnés, et beaucoup d'entre eux sont assez bons.Je voulais juste ajouter que le chèque
not a
sera également passer pour None et d'autres types de structures vides.Si vous voulez vraiment pour vérifier si la liste est vide, vous pouvez le faire:
if isinstance(a, list) and len(a)==0:
print("Received an empty list")
Inspirée par @dubiousjim la solution, je propose d'utiliser un contrôle général de savoir si c'est quelque chose de itérable
import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)
Note:une chaîne de caractères est considéré comme itératif.- ajouter and not isinstance(a,(str,unicode)) si vous voulez la chaîne vide pour être exclu
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
Vous pouvez même essayer d'utiliser bool() comme ceci
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
J'aime cette façon de vérifier la liste est vide ou pas.
Très pratique et utile.
Moyen Simple est de vérifier la longueur est égale à zéro.
if len(a) == 0:
print("a is empty")
print('not empty' if a else 'empty')
un peu plus pratique:
a.pop() if a else None
De python3, vous pouvez utiliser
a == []
pour vérifier si la liste est vide
EDIT :Cela fonctionne avec python2.7 trop..
Je ne suis pas sûr de savoir pourquoi il y en a tellement compliqué réponses.Il est assez clair et simple
nous pourrions utiliser un simple if else:
list=[]
if len(list)==0:
print ("list is empty")
else:
print ("list is not empty")
Utilisez simplement is_empty() ou la fonction comme:-
def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False
Il peut être utilisé pour n'importe quel data_structure comme une liste de tuples, dictionnaire et beaucoup plus.Par les présentes, vous pouvez l'appeler plusieurs fois en utilisant seulement is_empty(any_structure).
Pour vérifier si une liste est vide ou pas, vous pouvez l'utiliser de deux manières suivantes.Mais rappelez-vous, il convient d'éviter le chemin de explicitement vérification d'une séquence ou d'une liste (c'est un
less pythonicfaçon):
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".
La deuxième manière est un
more pythonicun.Cette méthode est une manière implicite de vérification et bien plus préférable que la précédente.
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"
Espérons que cette aide.
Vérifier si: len(list) == 0 retourne: True
Si vous voulez vérifier si la liste est vide;
l = []
if l:
# do your stuff.
Si vous voulez vérifier la météo toutes les valeurs de la liste est vide.
l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
# do your stuff.
Cependant, ce sera Vrai pour la liste vide.
def empty_list(lst):
if len(lst) ==0:
return false
else:
return all(bool(x) for x in l)
Maintenant, vous pouvez utiliser:
if empty_list(lst):
# do your stuff.
La valeur de vérité d'une liste vide est False alors que pour un non-vide de la liste, il est True.
Ce qui m'a amené ici est un particulier de cas d'utilisation:En fait, je voulais un la fonction de me dire si une liste est vide ou pas.Je voulais éviter d'écrire ma propre fonction ou à l'aide d'une lambda-expression ici (parce qu'il me semblait, comme il devrait être assez simple):
foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))
Et, bien sûr, il y a une façon très naturelle de le faire:
foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))
Bien sûr, ne pas utilisation bool dans if (c'est à dire, if bool(L):) parce que c'est implicite.Mais, pour le cas où "n'est pas vide" est requis explicitement comme une fonction, bool est le meilleur choix.
Un dingo façon d'utiliser pop et try except clause (recommandé):
a = []
try:
a.pop()
print('list isn\'t empty')
except:
print('list is empty')
Sortie:
list is empty
Officieux de l'approche :
a = []
try:
print(a[-1])
except IndexError:
print("List is empty")
