La pythonic façon de le faire est de la PEP 8 guide de style (où Oui signifie "recommandé" et Non signifie "non recommandé"):

pour les séquences (chaînes, listes, tuples), utilisez le fait que les séquences vides sont fausses.

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):

je le 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 en train de généraliser la question au-delà des listes, donc j'ai pensé que je voudrais ajouter une mise en garde pour un type différent de séquence que beaucoup de gens pourraient utiliser, d'autant plus que c'est le premier succès de google pour "test Python empty array".}

D'autres méthodes ne fonctionnent pas pour les tableaux numpy

vous devez être prudent avec des tableaux obliques, parce que d'autres méthodes qui fonctionnent bien pour list s ou d'autres les conteneurs standard sont défectueux pour les tableaux numpy. J'explique pourquoi ci-dessous, mais en bref, la méthode préférée est d'utiliser size .

Le "pythonic" façon ne fonctionne pas: Partie 1

la méthode "pythonic" échoue avec les tableaux numpy parce que numpy tente de lancer le tableau à un tableau de bool s, et if x tente d'évaluer tous ces bool s à la fois pour une sorte de valeur de vérité agrégée. Mais ce n'est pas tout sens, donc vous obtenez 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()

Le "pythonic" façon ne fonctionne pas: Partie 2

Mais au moins le cas ci-dessus vous indique qu'il a échoué. S'il vous arrive d'avoir un tableau numpy avec exactement un élément, l'instruction if "fonctionnera", dans le sens où vous n'obtiendrez pas d'erreur. Cependant, si un élément se trouve être 0 (ou 0.0 , ou false , ...), la déclaration if résultat incorrect 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.

en utilisant len peut donner des résultats inattendus

par exemple,

len( numpy.zeros((1,0)) )

retourne 1, même si le tableau a zéro éléments.

La numpythonic façon

comme expliqué dans le 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 que ce soit un list , un numpy array, ou autre chose, vous pouvez combiner cette approche avec la réponse @dubiousjim donne pour s'assurer que le bon test est utilisé pour chaque type. Pas très "pythonique", mais il s'avère que numpy a intentionnellement cassé pythonicité dans au moins ceci sens.

si vous avez besoin de faire plus que simplement vérifier si l'entrée est vide, et que vous utilisez d'autres fonctionnalités numpy comme l'indexation ou les opérations mathématiques, il est probablement plus efficace (et certainement plus courant) de forcer l'entrée à être un tableau numpy. Il ya quelques belles fonctions pour faire cela 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 le convertit optionnellement à votre choisi dtype . Il est donc très rapide quand il peut être, et il assure que vous obtenez juste à supposer que l'entrée est un tableau de numpy. Nous utilisons généralement le même nom, car la conversion en un tableau ne le ramènera pas en dehors de l'actuel scope :

x = numpy.asarray(x, dtype=numpy.double)

cela fera fonctionner le x.size dans tous les cas que je vois sur cette page.

une liste vide est elle-même considérée comme fausse dans le test de la vraie valeur (voir documentation python ):

a = []
if a:
     print "not empty"

@Daren Thomas

EDIT: un autre point contre les tests la liste vide comme Faux: Qu' 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 collection de duck à quack "Faux" quand il n'a pas d'éléments?

votre collection de Duck devrait implémenter __nonzero__ ou __len__ donc le SI a: fonctionnera sans problème.

meilleur moyen de vérifier si une liste est vide

par exemple, s'il est passé ce qui suit:

a = []

Comment vérifier si a est vide?

Courte Réponse:

placer la liste dans un contexte booléen (par exemple, avec une déclaration if ou while ). Il vérifiera False s'il est vide, et True autrement. Pour exemple:

if not a:                           # do this!
    print('a is an empty list')

appel à L'Autorité

PEP 8 , le guide officiel du style Python pour le code Python dans la bibliothèque standard de Python, affirme:

pour les séquences (chaînes, listes, tuples), utilisez le fait que les séquences vides sont fausses.

Yes: if not seq:
     if seq:

No: if len(seq):
    if not len(seq):

nous devrions nous attendre à ce que le code de bibliothèque standard soit aussi performant et correct que possible. Mais pourquoi est-ce le cas, et pourquoi avons-nous besoin de cette orientation?

explication

je vois souvent du code comme celui-ci par des programmeurs expérimentés novices en Python:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

et les utilisateurs de langues paresseuses peuvent être tentés de le faire:

if a == []:                         # Don't do this!
    print('a is an empty list')

Ces sont corrects dans leurs autres langues. Et c'est même sémantiquement correct en Python.

But nous le considérons comme non-pythonique parce que Python supporte ces sémantiques directement dans l'interface de l'objet list via la coercition booléenne.

De la docs (et noter précisément l'inclusion de la liste vide, [] ):

par défaut, un objet est considéré comme vrai à moins que sa classe ne définisse soit une méthode __bool__() qui retourne False ou une méthode __len__() qui renvoie à zéro, appelé avec l'objet. Voici la plupart des objets intégrés considérés comme faux:

• constantes définies comme fausses: None et False .
• 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 la documentation du datamodel:

object.__bool__(self)

appelé à mettre en œuvre le test de la valeur de vérité et l'opération intégrée bool() ; devrait retourner False ou True . Lorsque cette méthode n'est pas définie, __len__() est appelé, s'il est défini, et l'objet est considéré comme vrai si son résultat est non nul. Si une classe définit ni __len__() ni __bool__() , toutes ses instances sont considérées comme vraies.

et

object.__len__(self)

appelé à implémenter la fonction intégrée len() . Devrait retourner la longueur de l'objet, un entier >= 0. De plus, un objet qui ne définit pas une méthode __bool__() et dont la méthode __len__() retourne zéro est considéré comme étant faux dans un contexte Booléen.

donc à la place 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')

Faites ceci:

if not a:
    print('a is an empty list')

Faire ce qui est Pythonic rapporte habituellement dans la performance:

ça paie? (Notez que moins de temps pour effectuer une opération équivalente est préférable:)

>>> 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 la construction et le retour d'une liste vide, que vous pourriez soustraire des coûts des contrôles de vide utilisés ci-dessus:

>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342

nous voyons que soit vérification de la longueur avec la fonction intégrée len par rapport à 0 ou vérification par rapport à une liste vide est beaucoup moins performant que l'utilisation de la syntaxe intégrée de la langue telle que documentée.

pourquoi?

pour le len(a) == 0 contrôle:

tout d'abord Python doit vérifier les globals pour voir si len est ombragé.

alors il doit appeler la fonction, charger 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 [] == [] il doit construire une liste inutile et puis, encore une fois, faire l'opération de comparaison en Python machine virtuelle (par opposition à C)

>>> dis.dis(lambda: [] == [])
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

la méthode "Pythonic" est une vérification beaucoup plus simple et plus rapide puisque la longueur de la liste est mise en cache dans l'en-tête d'instance de l'objet:

>>> dis.dis(lambda: not [])
  1           0 BUILD_LIST               0
              2 UNARY_NOT
              4 RETURN_VALUE

la Preuve de la C de la source et de la documentation

PyVarObject

il s'agit d'une extension de PyObject qui ajoute le ob_size champ. Ce n'est utilisé que pour les objets qui ont une certaine idée de la longueur. Ce type n'apparaît pas souvent dans L'API Python/C. Il correspond aux champs définis par l'expansion de la macro PyObject_VAR_HEAD .

à Partir de la source c dans 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

j'ai aimé faire des recherches et j'ai passé beaucoup de temps à préparer mes réponses. Si vous pensez que j'oublie quelque chose, s'il vous plaît laissez - moi savoir dans un commentaire.

Patrick (accepté) réponse est juste: if not a: est la bonne façon de le faire. la réponse de Harley Holcombe, , est exacte: elle figure dans le guide de style PEP 8. Mais ce qu'aucune des réponses n'explique, c'est pourquoi c'est une bonne idée de suivre l'idiome-même si vous trouvez personnellement qu'il n'est pas assez explicite ou déroutant pour les utilisateurs de Ruby ou autre.

code Python, et la communauté Python, a des idiomes très forts. A la suite de ces les idiomes rendent votre code plus facile à lire pour toute personne expérimentée en Python. Et quand vous violez ces idiomes, c'est un signal fort.

il est vrai que if not a: ne distingue pas les listes vides de None , ou les numéros 0, ou les tuples vides, ou les types de collection vides créés par l'utilisateur, ou les types de collection vides créés par l'utilisateur qui ne sont pas tout à fait des types de collection, ou les tableaux NumPy à un seul élément agissant comme des scalaires avec des valeurs falsey, etc. Et parfois, il est important d'être explicite à ce sujet. Et dans ce cas, vous savez ce que vous voulez être explicite Sur, donc vous pouvez tester pour exactement cela. Par exemple, if not a and a is not None: signifie" Tout ce qui est falsey sauf aucun", tandis que if len(a) != 0: signifie" seulement des séquences vides-et tout ce qui est autre qu'une séquence est une erreur ici", et ainsi de suite. En plus de tester exactement ce que vous voulez tester, cela indique aussi au lecteur que ce test est important.

mais quand vous n'avez rien à dire, rien autre que if not a: est trompeur le lecteur. Vous signalez quelque chose d'aussi important quand ce n'est pas le cas. (Vous pouvez aussi rendre le code moins flexible, ou plus lent, ou peu importe, mais tout cela est moins important.) Et si vous habituellement induire le lecteur en erreur comme ceci, puis quand vous faire besoin de faire une distinction, il va passer inaperçu parce que vous avez été" crying wolf " sur tout votre code.

j'ai vu ci-dessous comme préféré:

if not a:
    print("The list is empty or null")

pourquoi vérifier?

personne ne semble avoir abordé la question de votre besoin pour tester la liste en premier lieu. Parce que vous n'avez fourni aucun contexte supplémentaire, je peux imaginer que vous n'aurez pas besoin de faire cette vérification en premier lieu, mais que vous n'êtes pas familier avec le traitement de liste en Python.

je dirais que la façon la plus pythonique n'est pas de vérifier du tout, mais plutôt de simplement traiter la liste. De cette façon, il fera la bonne chose, que ce soit vide ou plein.

a = []

for item in a:
    <do something with item>

<rest of code>

ceci a l'avantage de manipuler tout contenu de a , sans exiger un contrôle spécifique pour le vide. Si a est vide, le bloc dépendant ne s'exécutera pas et l'interpréteur tombera à la ligne suivante.

si vous avez réellement besoin de vérifier le tableau pour le vide, les autres réponses sont suffisantes.

len() est une opération O(1) pour listes, chaînes, dicts et sets Python. Python garde en interne la trace du nombre d'éléments dans ces conteneurs.

JavaScript a une notion similaire de truthy / falsy .

j'avais écrit:

if isinstance(a, (list, some, other, types, i, accept)) and not a:
    do_stuff

qui a été voté -1. Je ne suis pas sûr que ce soit parce que les lecteurs se sont opposés à la stratégie ou ont pensé que la réponse n'était pas utile telle que présentée. Je ferai comme si c'était le dernier, puisque---ce qui compte comme "pythonique"--c'est la bonne stratégie. Sauf si vous avez déjà exclu, ou êtes prêt à traiter les cas où a est, par exemple, False , vous avez besoin d'un test plus restrictif que juste if not a: . Vous pourriez utilisez 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 à la réponse de @Mike, ci-dessus. La troisième ligne pourrait également être remplacée par:

elif isinstance(a, (list, tuple)) and not a:

si vous voulez seulement accepter des instances de types particuliers (et leurs sous-types), ou avec:

elif isinstance(a, (list, tuple)) and not len(a):

vous pouvez vous échapper sans la vérification de type explicite, mais seulement si le contexte environnant vous assure déjà que a est une valeur des types vous êtes prêt à gérer, ou si vous êtes sûr que les types que vous n'êtes pas prêt à gérer vont générer des erreurs (par exemple, un TypeError si vous appelez len sur une valeur pour laquelle il n'est pas défini) que vous êtes prêt à gérer. En général, les conventions" pythonic " semblent aller dans cette dernière direction. Serrez-le comme un canard et laissez-le soulever un DuckError s'il ne sait pas faire coin. Vous devez encore penser sur ce type d'hypothèses que vous faites, si, et si le des 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ù simplement compter aveuglément sur len ou le typographie booléen peut ne pas faire exactement ce que vous attendez.

Python est très uniforme dans le traitement du vide. Étant donné ce qui suit:

a = []

.
.
.

if a:
   print("List is not empty.")
else:
   print("List is empty.")

vous cochez simplement la liste a avec un" si " pour voir si elle est vide. De ce que j'ai lu et appris, c'est le "Pythonic" façon de voir si une liste ou un tuple est vide.

quelques méthodes que j'utilise:

if not a:
    print "list is empty"


if len(a) == 0:
    print "list is empty"

à Partir de documentation sur la valeur de vérité de test:

toutes les valeurs autres que celles énumérées ici sont considérées comme True

• None
• False
• zéro de tout type numérique, par exemple, 0 , 0.0 , 0j .
• toute séquence vide, par exemple '' , () , [] .
• toute correspondance vide, par exemple {} .
• instances de classes définies par l'utilisateur, si la classe définit une méthode __bool__() ou __len__() , lorsque cette méthode retourne le zéro entier ou la valeur de bool False .

comme on peut le voir, la liste vide [] est falsy , donc faire ce qui serait fait à une valeur booléenne sonne le plus efficace:

if not a:
    print('"a" is empty!')

voici quelques façons de vérifier si une liste est vide:

a = [] #the list

1) la manière pythonique assez simple:

if not a:
    print("a is empty")

En Python, contenants vides , tels que les listes,les tuples,les décors,les dicts,variables, etc sont considérés comme des False . On pourrait simplement considérer la liste comme un prédicat ( retournant une valeur booléenne ). Et une valeur True indiquerait qu'il est non-vide.

2) une façon très explicite: utiliser le len() pour trouver la longueur et vérifier si elle égale à 0 :

if len(a) == 0:
    print("a is empty")

3) ou la comparer à une liste anonyme vide:

if a == []:
    print("a is empty")

4) une autre encore stupide façon de 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."

lisible et vous n'avez pas à vous soucier d'appeler une fonction comme len() pour itérer à travers la variable. Bien que je ne sois pas tout à fait sûr de ce Qu'est la notation BigO de quelque chose comme ça... mais Python est si rapide que je doute que ça ait de l'importance à moins que a soit gigantesque.

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 tester pour None et pour le vide séparément car ce sont deux états différents. Le code ci-dessus produit la sortie suivante:

list is None 
list is empty 
list has 3 elements

bien que cela ne vaille rien que None soit faux. 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 prévu

list is empty
list is empty
list has 3 elements

une autre façon simple pourrait être

a = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")

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.

inspiré par la solution de @dubiousjim, je propose d'utiliser une vérification générale supplémentaire pour savoir si c'est quelque chose d'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ée comme itérable. - ajouter and not isinstance(a,(str,unicode)) si vous voulez que la chaîne vide soit exclue

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 vous voulez vérifier si la liste est vide;""

l = []
if l:
    # do your stuff.

si vous voulez vérifier les conditions météorologiques, toutes les valeurs dans la liste sont vides.

l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
    # do your stuff.

cependant ceci 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 une liste non vide elle est True .

utilisez simplement is_empty () ou faites une 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 quelle structure de données comme une liste,des tuples, un dictionnaire et beaucoup d'autres. Par ceux-ci, vous pouvez l'appeler plusieurs fois en utilisant juste is_empty(any_structure) .

officieux de l'approche :

 a = []
 try:
  print(a[-1])
 except IndexError:
  print("List is empty")

regardez le code suivant exécuté sur le terminal interactif Python.

>>> a = []
>>> if a:
...     print "List is not empty";
... else:
...     print "List is empty"
... 
List is empty
>>> 
>>> a = [1, 4, 9]
>>> if a:
...     print "List is not empty";
... else:
...     print "List is empty"
... 
List is not empty
>>> 

je pense que les gens ont suggéré pour

if len(list1) == 0:
    print("is a good way")

ou len vous pouvez compter par

if list1.__ len__()==0:
    print("list1 is empty")

vous pouvez utiliser une voie de plus

if list1.__ sizeof__() == 40:
    print("list1 is empty")

taille de la liste vide est toujours 40.

, Vous pourriez faire:

lst = []
any(lst)   ##this returns False