¿Cómo verifico si una lista está vacía?

Question

Por ejemplo, si pasó lo siguiente:

a = []

¿Cómo puedo comprobar si a ¿esta vacio?

Answer 1

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

Usando la booleanidad implícita del vacío list es bastante pitónico.

Answer 2

La forma pitónica de hacerlo es desde el Guía de estilo PEP 8 (dónde Sí significa "recomendado" y No significa "no recomendado"):

Para secuencias (cadenas, listas, tuplas), utilice el hecho de que las secuencias vacías son falsas.

Sí: if not seq:
     if seq:

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

Answer 3

Lo prefiero explícitamente:

if len(li) == 0:
    print('the list is empty')

De esta manera queda 100% claro que li es una secuencia (lista) y queremos probar su tamaño.mi problema con if not li: ... es que da la falsa impresión de que li es una variable booleana.

Answer 4

_{Otras personas parecen estar generalizando la pregunta más allá de las listas, así que pensé en agregar una advertencia para un tipo diferente de secuencia que mucha gente podría usar, especialmente porque este es el primer resultado de Google para "matriz vacía de prueba de Python". .}

Otros métodos no funcionan para matrices NumPy

Debe tener cuidado con las matrices NumPy, porque otros métodos que funcionan bien para lists u otros contenedores estándar fallan para las matrices NumPy.Te explico por qué a continuación, pero en resumen, el metodo preferido es usar size.

La forma "pitónica" no funciona:Parte 1

La forma "pythonic" falla con las matrices NumPy porque NumPy intenta convertir la matriz en una matriz de boolarena if x trata de evaluar todos esos bools a la vez para algún tipo de valor de verdad agregado.Pero esto no tiene ningún sentido, por lo que obtienes 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()

La forma "pitónica" no funciona:Parte 2

Pero al menos el caso anterior te dice que falló.Si tiene una matriz NumPy con exactamente un elemento, el if La declaración "funcionará", en el sentido de que no obtendrá un error.Sin embargo, si ese elemento resulta ser 0 (o 0.0, o False, ...), el if declaración resultará incorrectamente en False:

>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x

Pero claramente x existe y no está vacío!Este resultado no es el que querías.

Usando len puede dar resultados inesperados

Por ejemplo,

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

devuelve 1, aunque la matriz tenga cero elementos.

La forma numpitónica

Como se explica en el Preguntas frecuentes sobre ciencia ficción, el método correcto en todos los casos en los que sabes que tienes una matriz NumPy es usar 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 no está seguro de si podría ser un list, una matriz NumPy u otra cosa, puede combinar este enfoque con la respuesta que da @duriousjim para asegurarse de que se utilice la prueba adecuada para cada tipo.No es muy "pitónico", pero resulta que NumPy rompió intencionalmente la pitonicidad al menos en este sentido.

Si necesita hacer algo más que simplemente verificar si la entrada está vacía y está utilizando otras funciones de NumPy como indexación u operaciones matemáticas, probablemente sea más eficiente (y ciertamente más común) forzar la entrada. ser una matriz NumPy.Hay algunas funciones interesantes para hacer esto rápidamente; la más importante numpy.asarray.Esto toma su entrada, no hace nada si ya es una matriz, o envuelve su entrada en una matriz si es una lista, tupla, etc., y opcionalmente la convierte a su elección. dtype.Por lo tanto, es muy rápido siempre que puede ser y garantiza que puedas asumir que la entrada es una matriz NumPy.Por lo general, incluso usamos el mismo nombre, ya que la conversión a una matriz no volverá a salir del actual alcance:

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

Esto hará que el x.size comprobar el trabajo en todos los casos que veo en esta página.

Answer 5

La mejor manera de comprobar si una lista está vacía

Por ejemplo, si pasó lo siguiente:

a = []

¿Cómo verifico si a está vacío?

Respuesta corta:

Coloque la lista en un contexto booleano (por ejemplo, con un if o while declaración).probará False si está vacío y True de lo contrario.Por ejemplo:

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

Apelar a la autoridad

PEPE 8, la guía de estilo oficial de Python para el código Python en la biblioteca estándar de Python, afirma:

Para secuencias (cadenas, listas, tuplas), utilice el hecho de que las secuencias vacías son falsas.

Yes: if not seq:
     if seq:

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

Deberíamos esperar que el código de biblioteca estándar sea lo más eficaz y correcto posible.Pero, ¿por qué es así y por qué necesitamos esta orientación?

Explicación

Con frecuencia veo código como este de programadores experimentados nuevos en Python:

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

Y los usuarios de lenguajes perezosos pueden verse tentados a hacer esto:

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

Estos son correctos en sus respectivos otros idiomas.Y esto es incluso semánticamente correcto en Python.

Pero lo consideramos no Pythonico porque Python admite esta semántica directamente en la interfaz del objeto de lista mediante coerción booleana.

Desde el documentos (y tenga en cuenta específicamente la inclusión de la lista vacía, []):

Por defecto, un objeto se considera verdadero a menos que su clase define un __bool__() método que regresa False o un __len__() Método que devuelve cero, cuando se llama con el objeto.A continuación se muestran la mayoría de los objetos integrados que se consideran falsos:

• constantes definidas como falsas: None y False.
• cero de cualquier tipo numérico: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• secuencias y colecciones vacías: '', (), [], {}, set(), range(0)

Y la documentación del modelo de datos:

object.__bool__(self)

Llamado a implementar pruebas de valor de verdad y la operación incorporada bool();debería regresar False o True.Cuando este método no está definido, __len__() se llama, si está definido, y el objeto se considera verdadero si su resultado es distinto de cero.Si una clase no define ninguno __len__()ni __bool__(), todos sus casos se consideran verdaderos.

y

object.__len__(self)

Llamado para implementar la función incorporada. len().Debería devolver la longitud del objeto, un número entero >= 0.Además, un objeto que no define un __bool__() método y cuyo __len__() El método devuelve cero se considera falso en un contexto booleano.

Entonces en lugar de esto:

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

o esto:

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

Hacer esto:

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

Hacer lo que es Pythonic generalmente vale la pena en términos de rendimiento:

¿Vale la pena?(Tenga en cuenta que es mejor dedicar menos tiempo a realizar una operación equivalente :)

>>> 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

Para escalar, aquí está el costo de llamar a la función y construir y devolver una lista vacía, que puede restar de los costos de las comprobaciones de vacío utilizadas anteriormente:

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

Vemos eso cualquiera comprobar la longitud con la función incorporada len en comparación con 0 o comparar con una lista vacía es mucho menos rendimiento que usar la sintaxis incorporada del lenguaje como está documentado.

¿Por qué?

Para el len(a) == 0 controlar:

Primero Python tiene que comprobar los globales para ver si len está ensombrecido.

Luego debe llamar a la función, cargar 0, y haga la comparación de igualdad en Python (en lugar de con 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

y para el [] == [] tiene que crear una lista innecesaria y luego, nuevamente, realizar la operación de comparación en la máquina virtual de Python (a diferencia de C)

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

La forma "Pythonic" es una verificación mucho más simple y rápida ya que la longitud de la lista se almacena en caché en el encabezado de la instancia del objeto:

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

Evidencia de la fuente C y documentación.

PyVarObject

Esta es una extensión de PyObject eso suma el ob_size campo.Esto sólo se usa para objetos que tienen alguna noción de longitud.Este tipo no suele aparecer en la API de Python/C.Corresponde a los campos definidos por la ampliación de la PyObject_VAR_HEAD macro.

De la fuente c en Incluir/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

Disfruté investigando esto y dedico mucho tiempo a seleccionar mis respuestas.Si crees que estoy omitiendo algo, házmelo saber en un comentario.

Answer 6

Una lista vacía se considera falsa en las pruebas de valor verdadero (ver documentación de Python):

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

@Daren Tomás

EDITAR:Otro punto en contra de probar la lista vacía como falsa:¿Qué pasa con el polimorfismo?No debe depender de que una lista sea una lista.Debería quacarse como un pato: ¿cómo vas a hacer que tu pato coleccionista "falso" cuando no tiene elementos?

Tu duckCollection debería implementar __nonzero__ o __len__ entonces si a:Funcionará sin problemas.

Answer 7

Respuesta de Patrick (aceptada) es correcto: if not a: es la forma correcta de hacerlo. La respuesta de Harley Holcombe Es cierto que esto está en la guía de estilo PEP 8.Pero lo que ninguna de las respuestas explica es por qué es una buena idea seguir el modismo, incluso si personalmente encuentra que no es lo suficientemente explícito o confuso para los usuarios de Ruby o lo que sea.

El código Python y la comunidad Python tienen modismos muy fuertes.Seguir esos modismos hace que su código sea más fácil de leer para cualquier persona con experiencia en Python.Y cuando violas esos modismos, es una señal fuerte.

Eso es verdad if not a: no distingue listas vacías de None, o 0 numérico, o tuplas vacías, o tipos de colección vacíos creados por el usuario, o tipos vacíos de colección que no son del todo creados por el usuario, o una matriz NumPy de un solo elemento que actúa como escalares con valores falsos, etc.Y a veces es importante ser explícito al respecto.Y en ese caso, ya sabes qué desea ser explícito, para poder probar exactamente eso.Por ejemplo, if not a and a is not None: significa "cualquier cosa falsa excepto Ninguna", mientras que if len(a) != 0: significa "sólo secuencias vacías, y cualquier cosa que no sea una secuencia es un error aquí", y así sucesivamente.Además de probar exactamente lo que desea probar, esto también le indica al lector que esta prueba es importante.

Pero cuando no tienes nada sobre qué ser explícito, nada más que if not a: está engañando al lector.Estás señalando algo tan importante cuando no lo es.(Es posible que también estés haciendo que el código sea menos flexible, más lento o lo que sea, pero todo eso es menos importante). por costumbre engañar al lector de esta manera, entonces cuando hacer Si necesitas hacer una distinción, pasará desapercibido porque has estado "llorando lobo" en todo tu código.

Answer 8

¿Por qué comprobarlo?

Nadie parece haberse planteado cuestionar su necesidad para probar la lista en primer lugar.Debido a que no proporcionó ningún contexto adicional, me imagino que es posible que no necesite realizar esta verificación en primer lugar, pero no está familiarizado con el procesamiento de listas en Python.

Yo diría que el más pitónico La mejor manera es no verificar nada, sino simplemente procesar la lista.De esa manera hará lo correcto ya sea que esté vacío o lleno.

a = []

for item in a:
    <do something with item>

<rest of code>

Esto tiene la ventaja de manejar cualquier contenido de a, sin requerir un control específico de vacío.Si a está vacío, el bloque dependiente no se ejecutará y el intérprete pasará a la siguiente línea.

Si realmente necesita verificar si la matriz está vacía, las otras respuestas son suficientes.

Answer 9

len() es una operación O(1) para listas, cadenas, dictados y conjuntos de Python.Python realiza un seguimiento interno de la cantidad de elementos en estos contenedores.

javascript tiene una noción similar de verdad/falso.

Answer 10

He escrito:

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

que fue votado -1.No estoy seguro de si eso se debe a que los lectores se opusieron a la estrategia o pensaron que la respuesta no era útil tal como se presentó.Fingiré que fue lo último, ya que, sea lo que sea que se considere "pitónico", esta es la estrategia correcta.A menos que ya haya descartado o esté preparado para manejar casos en los que a es, por ejemplo, False, necesita una prueba más restrictiva que solo if not a:.Podrías usar algo como esto:

if isinstance(a, numpy.ndarray) and not a.size:
    do_stuff
elif isinstance(a, collections.Sized) and not a:
    do_stuff

la primera prueba es en respuesta a la respuesta de @ Mike, arriba.La tercera línea también podría sustituirse por:

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

si solo desea aceptar instancias de tipos particulares (y sus subtipos), o con:

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

Puede salirse con la suya sin la verificación de tipo explícita, pero sólo si el contexto circundante ya le asegura que a es un valor de los tipos que está preparado para manejar, o si está seguro de que los tipos que no está preparado para manejar van a generar errores (por ejemplo, un TypeError si llamas len en un valor para el cual no está definido) que está preparado para manejar.En general, las convenciones "pitónicas" parecen ir por este último camino.Aprietalo como un pato y deja que genere un DuckError si no sabe graznar.todavía tienes que pensar Sin embargo, se trata de qué tipo de suposiciones estás haciendo y de si los casos que no estás preparado para manejar adecuadamente realmente van a generar errores en los lugares correctos.Las matrices Numpy son un buen ejemplo en el que confiar ciegamente en len o es posible que el tipo booleano no haga exactamente lo que espera.

Answer 11

De documentación sobre las pruebas del valor de verdad:

Todos los valores distintos de los que se enumeran aquí se consideran True

• None
• False
• cero de cualquier tipo numérico, por ejemplo, 0, 0.0, 0j.
• cualquier secuencia vacía, por ejemplo, '', (), [].
• cualquier mapeo vacío, por ejemplo, {}.
• instancias de clases definidas por el usuario, si la clase define un __bool__() o __len__() método, cuando ese método devuelve el valor entero cero o bool False.

Como puede verse, lista vacía. [] es falso, por lo que hacer lo que se haría con un valor booleano parece más eficiente:

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

Answer 12

A continuación se muestran algunas formas de comprobar si una lista está vacía:

a = [] #the list

1) La forma pitónica bastante simple:

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

En pitón, contenedores vacios tales como listas, tuplas, conjuntos, dictados, variables, etc., se consideran False.Se podría simplemente tratar la lista como un predicado (devolviendo un valor booleano).y un True El valor indicaría que no está vacío.

2) Una forma mucho más explícita:utilizando el len() para encontrar la longitud y comprobar si es igual a 0:

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

3) O comparándolo con una lista vacía anónima:

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

4) Otro mas tonto manera de hacerlo es usar exception y iter():

try:
    next(iter(a))
    # list has elements
except StopIteration:
    print("Error: a is empty")

Answer 13

Prefiero lo siguiente:

if a == []:
   print "The list is empty."

Answer 14

Método 1 (preferido):

if not a : 
   print ("Empty") 

Método 2:

if len(a) == 0 :
   print( "Empty" )

Método 3:

if a == [] :
  print ("Empty")

Answer 15

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 veces es bueno hacer pruebas de None y para el vacío por separado ya que son dos estados diferentes.El código anterior produce el siguiente resultado:

list is None 
list is empty 
list has 3 elements

Aunque no vale nada eso None es falso.Entonces, si no desea separar la prueba para None-ness, no tienes que hacer eso.

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 lo esperado

list is empty
list is empty
list has 3 elements

Answer 16

Se han dado muchas respuestas y muchas de ellas son bastante buenas.Solo quería agregar que el cheque

not a

también pasará por None y otros tipos de estructuras vacías.Si realmente desea buscar una lista vacía, puede hacer esto:

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

Answer 17

Inspirándome en la solución de @dubiousjim, propongo utilizar una verificación general adicional para saber si es algo iterable.

import collections
def is_empty(a):
    return not a and isinstance(a, collections.Iterable)

Nota:una cadena se considera iterable.- agregar and not isinstance(a,(str,unicode)) si desea que se excluya la cadena vacía

Prueba:

>>> 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

Answer 18

Incluso puedes intentar usar bool() como este

    a = [1,2,3];
    print bool(a); # it will return True
    a = [];
    print bool(a); # it will return False

Me encanta esta forma de verificar que la lista esté vacía o no.

Muy práctico y útil.

Answer 19

Una forma sencilla es comprobar que la longitud sea igual a cero.

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

Answer 20

print('not empty' if a else 'empty')

un poco más práctico:

a.pop() if a else None

Answer 21

Desde python3 en adelante puedes usar

a == []

para comprobar si la lista está vacía

EDITAR :Esto también funciona con python2.7.

No estoy seguro de por qué hay tantas respuestas complicadas.Es bastante claro y sencillo.

Answer 22

podríamos usar un simple if else:

list=[]
if len(list)==0:
    print ("list is empty")
else:
    print ("list is not empty")

Answer 23

Simplemente use is_empty() o haga una función como:-

def is_empty(any_structure):
    if any_structure:
        print('Structure is not empty.')
        return True
    else:
        print('Structure is empty.')
        return False  

Se puede utilizar para cualquier estructura de datos, como una lista, tuplas, diccionario y muchos más.Con estos, puedes llamarlo muchas veces usando solo is_empty(any_structure).

Answer 24

Para comprobar si una lista está vacía o no, puede utilizar las dos formas siguientes.Pero recuerde, debemos evitar la forma de verificar explícitamente una secuencia o lista (es una less pythonic forma):

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 segunda manera es una more pythonic uno.Este método es una forma implícita de comprobar y mucho más preferible que el anterior.

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"

Espero que esto ayude.

Answer 25

Comprobar si: len(list) == 0 devoluciones: True

Answer 26

Si desea comprobar si la lista está vacía;

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

Si desea comprobar el tiempo, todos los valores de la lista están vacíos.

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

Sin embargo, esto será Verdadero para una lista vacía.

def empty_list(lst):
    if len(lst) ==0:
        return false
    else:
        return all(bool(x) for x in l)

Ahora puedes usar:

if empty_list(lst):
    # do your stuff.

Answer 27

El valor de verdad de una lista vacía es False mientras que para una lista no vacía es True.

Answer 28

Lo que me trajo aquí es un caso de uso especial:En realidad quería un función para decirme si una lista está vacía o no.Quería evitar escribir mi propia función o usar una expresión lambda aquí (porque parecía que debería ser bastante simple):

    foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))

Y, por supuesto, existe una forma muy natural de hacerlo:

    foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))

Por supuesto, hazlo no usar bool en if (es decir., if bool(L):) porque está implícito.Pero, para los casos en los que "no está vacío" se necesita explícitamente como función, bool es la mejor opción.

Answer 29

Una forma tonta de usar pop y try except cláusula (no recomendada):

a = []
try:
    a.pop()
    print('list isn\'t empty')
except:
    print('list is empty')

Producción:

list is empty

Answer 30

Un enfoque no oficial:

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