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

Por ejemplo, si pasa lo siguiente:

a = []

¿Cómo verifico para ver si a ¿esta vacio?

preguntado el 10 de septiembre de 08 a las 04:09

27 Respuestas

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

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

contestado el 28 de mayo de 20 a las 19:05

Jugando al abogado del diablo. No entiendo por qué este idioma se considera pitónico. 'Explícito es mejor que implícito', ¿correcto? Esta comprobación no parece muy explícita sobre lo que se está comprobando. - james mc mahon

@JamesMcMahon: es un compromiso entre lo explícito y la flexibilidad de tipos. en general, "ser explícito" significa no hacer cosas "mágicas". por otro lado, "escribir pato" significa trabajar con interfaces más generales, en lugar de verificar explícitamente los tipos. entonces algo como if a == [] está forzando un tipo particular (() == [] is False). aquí, el consenso general parece ser que gana la tipificación de pato (en efecto, diciendo que __nonzero__ es la interfaz para probar la vacuidad docs.python.org/reference/datamodel.html#object.__nonzero__) - Andrew Cooke

Este método no funciona en matrices numpy ... así que creo que si len (a) == 0 es preferible tanto en términos de "tipificación de pato" como de implícita. - Señor me adora

La forma canónica de saber si una matriz en C está vacía es desreferenciar el primer elemento y ver si es nulo, asumiendo una matriz con terminación nula. De lo contrario, comparar su longitud con cero es completamente ineficaz si la matriz tiene un tamaño significativo. Además, normalmente, no asignaría memoria para una matriz vacía (el puntero permanece nulo), por lo que no tiene sentido intentar obtener su longitud. No estoy diciendo que len (a) == 0 no sea una buena forma de hacerlo, simplemente no me grita 'C' cuando la veo. - sleblanc

Procedente de un lenguaje que pretende ser una especie de poesía, este mecanismo es pura basura. Semánticamente, estar vacío es muy diferente a no estar - edwin rodriguez

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

Para las 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):

respondido 26 mar '18, 18:03

La segunda forma parece mejor si desea señalar que seq se espera que sea una especie de objeto similar a una lista. - Bolígrafo Ben

@BallpointBen que, dirían los defensores del pitonismo, debería estar implícito en la forma en que se nombra la variable, tanto como sea posible - ajolote

@BallpointBen intenta usar Python tipo insinuación para señalar lo que debería ser una variable. Fue introducido en 3.5. - Boris

numpy rompió este modismo ... seq = numpy.array ([1,2,3]) seguido de if not seq genera una excepción "ValueError: El valor de verdad de una matriz con más de un elemento es ambiguo. Use a.any () o a.all () "- Señor me adora

A pesar de todos los defensores de Pythonic, estoy con @BallpointBen en eso si escribiste por error seq = [0] as seq = 0, len(seq) le ayudará a detectar el error. Errar es humano. También lo es un programador. - aafulei

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.

Respondido el 09 de Septiembre de 17 a las 05:09

Verificar si la longitud de una lista es igual a cero, en lugar de simplemente verificar si la lista es falsa, es feo y poco pitónico. Cualquiera que esté familiarizado con Python no pensará li es un bool en absoluto, y no le importará. Si es importante, debe agregar un comentario, no más código. - Carlos Smith

Esto parece una prueba innecesariamente precisa, que a menudo es más lenta y siempre es menos legible en mi humilde opinión. En lugar de verificar el tamaño de algo vacío, ¿por qué no simplemente verificar si está vacío? - John B

De todos modos, la razón por la que esto es malo (y que violar modismos en un lenguaje con modismos fuertes como Python es malo en general) es que le indica al lector que está verificando específicamente la longitud por alguna razón (por ejemplo, porque quiere None or 0 para plantear una excepción en lugar de pasar). Por lo tanto, cuando lo hace sin ningún motivo, es engañoso, y también significa que cuando su código Necesito hacer la distinción, la distinción es invisible porque ha "gritado lobo" en todo el resto de la fuente. - abarnert

Creo que esto solo alarga innecesariamente el código. De lo contrario, ¿por qué no ser aún más "explícito" con if bool(len(li) == 0) is True:? - augurar

@Jabba será O (1) en muchos casos (aquellos en los que trabaja con los tipos de datos integrados), pero simplemente no puede confiar en eso. Es posible que esté trabajando con un tipo de datos personalizado que no tenga esta propiedad. También puede decidir agregar este tipo de datos personalizados más adelante, después de haber escrito este código. - ralokt

Este es el primer acierto de Google para "Python test empty array" y consultas similares, además de que 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 Puede usar.

Otros métodos no funcionan para matrices NumPy

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

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

La forma "pitónica" falla con las matrices NumPy porque NumPy intenta convertir la matriz a una matriz de bools y if x intenta evaluar todos esos bools a la vez por algún tipo de valor de verdad agregado. Pero esto no tiene ningún sentido, así 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 es 0 (o 0.0o False, ...), la 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.

Usar len puede dar resultados inesperados

Por ejemplo, los servicios administrativos de

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

devuelve 1, aunque la matriz tenga cero elementos.

La forma numpythonic

Como se explica en el Preguntas frecuentes sobre ciencia, el método correcto en todos los casos en los que sabe que tiene 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, o algo más, puede combinar este enfoque con la respuesta que da @dubiousjim para asegurarse de que se utilice la prueba correcta 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 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 para ser una matriz NumPy. Hay algunas funciones interesantes para hacer esto rápidamente, lo 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 simplemente asuma que la entrada es una matriz NumPy. Por lo general, incluso usamos el mismo nombre, ya que la conversión a una matriz no saldrá de la actual alcance:

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

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

Respondido el 25 de junio de 19 a las 16:06

Vale la pena señalar que esto no es un defecto en Python, sino más bien una ruptura intencional del contrato por parte de numpy - numpy es una biblioteca con un caso de uso muy específico, y tiene una definición "natural" diferente de lo que es la veracidad en una matriz para el estándar de Python para contenedores. Tiene sentido optimizar para ese caso, de la manera que pathlib usos / para concatenar caminos en lugar de + - no es estándar, pero tiene sentido en contexto. - gareth latty

Acordado. Mi punto es solo que es importante recordar que numpy ha tomado la decisión de romper el tipeo de pato para los if x y len(x) modismos y, a veces, esa rotura puede ser muy difícil de detectar y depurar. - Mike

No sé, para mí, si un método llamado len (x) no devuelve la longitud de la matriz debido a suposiciones, su nombre está mal diseñado. - Dalton

Esta pregunta no tiene nada que ver con matrices numpy - picante

@ppperry Sí, la pregunta original no se refería a las matrices Numpy, pero cuando se trabaja con esos argumentos y posiblemente con el tipo pato, esta pregunta se vuelve muy relevante. - Peterhil

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

Por ejemplo, si pasa 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 or 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')

PEP 8

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

Para las 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 guía?

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 tener la tentación de 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 Pythonic 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, []):

De forma predeterminada, un objeto se considera verdadero a menos que su clase defina un __bool__() método que regresa False o con una __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 para implementar pruebas de valor de verdad y la operación incorporada bool(); debería volver False or 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 ni __len__() ni __bool__(), todas sus instancias se consideran verdaderas.

y

object.__len__(self)

Llamado para implementar la función incorporada len(). Debe devolver la longitud del objeto, un 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 Pythonic suele dar sus frutos en rendimiento:

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

>>> 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 los controles de vacío utilizados anteriormente:

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

Vemos eso ya sea comprobar la longitud con la función incorporada len en comparación con 0 or comparar con una lista vacía es mucho más menos eficaz que usar la sintaxis incorporada del lenguaje tal como se documenta.

¿Por qué?

Para el len(a) == 0 comprobar:

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

Entonces 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 construir una lista innecesaria y luego, nuevamente, hacer 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 agrega el ob_size campo. Esto solo 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 expansión del 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

Respuesta a los comentarios:

Me gustaría señalar que esto también es cierto para el caso no vacío, aunque es bastante feo como con l=[] luego %timeit len(l) != 0 90.6 ns ± 8.3 ns, %timeit l != [] 55.6 ns ± 3.09, %timeit not not l 38.5 ns ± 0.372. Pero no hay forma de que nadie disfrute not not l a pesar de triplicar la velocidad. Parece ridículo. Pero la velocidad gana
Supongo que el problema es probar con el tiempo, ya que if l: es suficiente pero sorprendentemente %timeit bool(l) rinde 101 ns ± 2.64 ns. Interesante, no hay forma de coaccionar a bool sin esta penalización. %timeit l es inútil ya que no se produciría ninguna conversión.

Magia de ipython, %timeit, no es del todo inútil aquí:

In [1]: l = []                                                                  

In [2]: %timeit l                                                               
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l                                                           
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l                                                       
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Podemos ver que hay un poco de costo lineal por cada not aquí. Queremos ver los costos Siendo el resto de las cosas iguales, es decir, todo lo demás igual, donde todo lo demás se minimiza en la medida de lo posible:

In [5]: %timeit if l: pass                                                      
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass                                                  
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass                                              
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Ahora veamos el caso de una lista vacía:

In [8]: l = [1]                                                                 

In [9]: %timeit if l: pass                                                      
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass                                                 
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass                                             
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Lo que podemos ver aquí es que hay poca diferencia si pasa en un bool a la verificación de condición o la lista en sí, y en todo caso, dar la lista, tal como está, es más rápido.

Python está escrito en C; usa su lógica en el nivel C. Todo lo que escriba en Python será más lento. Y probablemente será órdenes de magnitud más lento a menos que esté utilizando los mecanismos integrados en Python directamente.

respondido 28 nov., 19:14

Me gustaría señalar que esto también es cierto para el caso no vacío, aunque es bastante feo como con l=[] luego %timeit len(l) != 0 90.6 ns ± 8.3 ns, %timeit l != [] 55.6 ns ± 3.09, %timeit not not l 38.5 ns ± 0.372. Pero no hay forma de que nadie disfrute not not l a pesar de triplicar la velocidad. Parece ridículo. Pero la velocidad gana gregorio morse

Supongo que el problema es probar con el tiempo, ya que if l: es suficiente pero sorprendentemente %timeit bool(l) rinde 101 ns ± 2.64 ns. Interesante, no hay forma de coaccionar a bool sin esta penalización. %timeit l es inútil ya que no se produciría ninguna conversión. - gregorio morse

¡La mejor respuesta hasta ahora, gracias! Señalar la verdadera lógica de Python con métodos mágicos y "Python está escrito en C; usa su lógica en el nivel C. Todo lo que escribas en Python será más lento. Y probablemente será órdenes de magnitud más lento" es la clave. de lo contrario, uno cae en "preferencias" y nunca llega a una conclusión adecuada. - ClementeWalter

¡Estupendo! ¡Esta es la mejor respuesta! Para cualquiera que lea desde 2020 (es diciembre, es casi 2021) y en el futuro. Haciendo if l es la forma "Pythonic" y la MEJOR forma, ya que este tipo lo explica muy bien y también proporcionó un código de muestra del rendimiento del tiempo calculado para cada respuesta sugerida que son if len(a) == 0, if [] == [] y if a Tan claramente esto (if a) es mucho más rápido y el que hay que practicar. - Oso de hielo

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

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

@Daren Thomas

EDITAR: Otro punto en contra de probar la lista vacía como Falso: ¿Qué pasa con el polimorfismo? No deberías depender de que una lista sea una lista. Debería graznar como un pato. ¿Cómo vas a conseguir que tu colección de patos grazne "Falso" cuando no tiene elementos?

Tu duckCollection debería implementar __nonzero__ or __len__ entonces el if a: funcionará sin problemas.

Respondido el 06 de Septiembre de 14 a las 02:09

Extraño como [] == False sin embargo, se evaluará como Falso - intercambio_información

@information_interchange Si desea verificar explícitamente la veracidad de un valor, use bool(). bool([]) == False evaluará a True como se esperaba. - augurar

Respuesta de Patrick (aceptada) es correcto: if not a: es la forma correcta de hacerlo. La respuesta de Harley Holcombe Tiene razón en que esto está en la guía de estilo de PEP 8. Pero lo que ninguna de las respuestas explica es por qué es una buena idea seguir el idioma, 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 de 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 las 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 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 estar explícito sobre eso. Y en ese caso, sabes qué desea ser explícito, para que pueda probar exactamente eso. Por ejemplo, if not a and a is not None: significa "cualquier cosa falsa excepto Ninguno", mientras que if len(a) != 0: significa "sólo secuencias vacías, y cualquier cosa además de 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 lo que ser explícito, nada más que if not a: engaña al lector. Estás señalando algo tan importante cuando no lo es. (También puede hacer que el código sea menos flexible, más lento o lo que sea, pero eso es menos importante). por costumbre engañar al lector de esta manera, entonces cuando usted do Necesito hacer una distinción, pasará desapercibido porque has estado "llorando como un lobo" en todo tu código.

contestado el 23 de mayo de 17 a las 12:05

"Y cuando violas esos modismos, es una señal fuerte". Puede ser una señal fuerte de que simplemente está trabajando con código escrito por alguien nuevo en Python, que es mucha gente - joel

¿Por qué comprobarlo?

Nadie parece haberse dirigido a cuestionar su necesitas para probar la lista en primer lugar. Debido a que no proporcionó contexto adicional, puedo imaginar que es posible que no necesite hacer 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 forma es no verificar en absoluto, sino simplemente procesar la lista. De esa manera, hará lo correcto, ya sea 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, aunque no requiere 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.

Respondido el 20 de junio de 20 a las 10:06

La cuestión es que comprobar si la lista está vacía es bastante importante, al menos para mí. ¿Ha considerado si hay algún script dentro? <rest of code> que podría utilizar el resultado de la for ¿círculo? O use directamente algunos valores en a? De hecho, si el script está diseñado para ejecutarse con una entrada estrictamente controlada, la verificación puede ser un poco innecesaria. Pero en la mayoría de los casos, la entrada varía y, por lo general, es mejor tener una verificación. - amarth gul

Respetuosamente, no. Lo que consideré fue alguien que no sabía lo suficiente sobre Python para saber que "si : ”Fue la respuesta correcta, se preguntó cómo buscar una lista vacía. Luego noté MUCHAS respuestas que ofrecían opiniones diferentes, pero ninguna parecía abordar la necesidad original. Eso es lo que traté de hacer con mi respuesta: que examinen la necesidad antes de continuar. Creo que sugerí tanto en mi respuesta, explícitamente. - Sr. Maravilloso

@ AmarthGûl - ¿Cómo podría uno obtener los resultados del bucle for al script dentro para ser procesado? ¿En una lista, quizás? ¿O tal vez un dict? Si es así, se aplica la misma lógica. No entiendo como entrada variable podría tener algún efecto dentro de cualquier tipo de código razonablemente diseñado, donde procesar una lista vacía sería una mala idea. - Sr. Maravilloso

Un poco antiguo, pero si solo estuviera verificando si la lista estaba vacía, para una lista no vacía, su código repite el proceso una y otra vez cuando OP simplemente está buscando una operación de verificación. Solo imagina un escenario en el peor de los casos para ese código cuando n se acerca al infinito ... DJK

@DJK - No, creo que todavía te lo estás perdiendo. Es de suponer que desea HACER algo con una lista, si tiene una. ¿Qué harías diferente si estuviera vacío? ¿Regresar temprano? ¿Y si no está vacío? ¿procesalo? El punto es, aún así, que tú probablemente no es necesario buscar una lista vacía, solo iterar sobre ella y haz lo que sea que vayas a hacer con los elementos. Si no hay elementos, fracasas. Si hay elementos, los procesa según sea necesario. El punto NO es usar el ejemplo PARA una verificación vacía, sino NO verificar en absoluto, solo procesar la lista. - Sr. Maravilloso

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 / falsedad.

Respondido el 14 de junio de 12 a las 02:06

He escrito:

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

que fue votado -1. No estoy seguro 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ó. Pretenderé que fue lo último, ya que --- lo que sea que cuente como "pitónico" --- esta es la estrategia correcta. A menos que ya lo 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 reemplazarse con:

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 sin la verificación de tipo explícita, pero solo 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 que no está definido) que está preparado para manejar. En general, las convenciones "pitónicas" parecen ir por este último camino. Apriétalo como un pato y déjalo generar un DuckError si no sabe graznar. Todavía tienes que pensar sobre qué tipo de suposiciones está haciendo, sin embargo, y si los casos que no está preparado para manejar correctamente realmente van a fallar en los lugares correctos. Las matrices Numpy son un buen ejemplo en el que confiar ciegamente en len o el encasillado booleano puede no hacer precisamente lo que esperas.

Respondido el 25 de junio de 15 a las 04:06

Es bastante raro que tenga una lista exhaustiva de 6 tipos que desee aceptar y no sea flexible para otros tipos. Cuando necesite ese tipo de cosas, probablemente quiera un abecedario. En este caso, probablemente sería uno de los ABC de stdlib, como collections.abc.Sized or collections.abc.Sequence, pero podría ser uno que escriba usted mismo y register(list) en. Si realmente tiene un código en el que es importante distinguir el vacío de otras falsey, y también para distinguir listas y tuplas de cualquier otra secuencia, entonces esto es correcto, pero no creo que tenga ese código. - abarnert

La razón por la que a la gente no le gusta esto es porque, en la mayoría de los casos, es completamente inadmisible. Python es un lenguaje de tipo pato, y este nivel de codificación defensiva lo obstaculiza activamente. La idea detrás del sistema de tipos de Python es que las cosas deberían funcionar siempre que el objeto pase las funciones de la manera que necesita. Al realizar comprobaciones de tipo explícitas, está obligando a la persona que llama a utilizar tipos específicos, yendo en contra de la esencia del lenguaje. Si bien ocasionalmente tales cosas son necesarias (excluyendo cadenas de ser tratadas como secuencias), tales casos son raros y casi siempre mejores como listas negras. - gareth latty

Si realmente quiere comprobar que el valor es exactamente [] y no algo falso de otro tipo, entonces seguramente if a == []: es necesario, en lugar de jugar con isinstance. - RemcoGerlich

Hay algunas coacciones automáticas para == aunque. Desde lo alto de mi cabeza, no puedo identificar ninguno por []. [] == () por ejemplo devoluciones False. Pero por ejemplo frozenset()==set() devoluciones True. Por lo tanto, vale la pena pensar al menos si algún tipo no deseado podría ser coaccionado para [] (o viceversa) al hacer a == []. - dudoso

@RemcoGerlich - isinstance () sigue siendo preferible en lugar de construir una lista vacía para comparar. Además, como señaló otro, el operador de igualdad puede invocar la conversión implícita de algunos tipos, lo que puede ser indeseable. No hay ninguna razón para codificar "a == []" y ese código definitivamente se marcaría como un defecto en cualquier revisión de código en la que haya participado. El uso de la herramienta adecuada según lo provisto por el lenguaje no debe considerarse "tonterías , "sino más bien" una buena técnica de programación ". - Sr. Maravilloso

De documentación sobre la prueba 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__() or __len__() método, cuando ese método devuelve el valor entero cero o bool False.

Como puede verse, lista vacía [] is falsedad, por lo que hacer lo que se haría con un valor booleano suena más eficiente:

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

Respondido el 11 de enero de 16 a las 17:01

@DJ_Stuffy_K afirmar qué en las pruebas unitarias, ¿una lista vacía? Solo usa assert(not myList). Si también desea afirmar que el objeto es un list, puedes usar assertIsInstance(). - Sнаđошƒаӽ

A continuación, se muestran algunas formas en las que puede verificar si una lista está vacía:

a = [] #the list

1) La forma pitónica bastante simple:

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

En Python contenedores vacios como listas, tuplas, conjuntos, dictados, variables, etc.se ven como False. Uno podría simplemente tratar la lista como un predicado (devolviendo un valor booleano). Y un True valor indicaría que no está vacío.

2) Una forma mucho más explícita: usando 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 forma de hacerlo es usando exception y iter():

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

respondido 28 nov., 16:14

Prefiero lo siguiente:

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

Respondido el 05 de enero de 19 a las 04:01

Esto va a ser más lento, ya que crea una instancia de una lista vacía adicional innecesariamente. - Carl Meyer

esto es menos legible que if not a: y se rompe más fácilmente. Por favor, no lo hagas. - desarrollo

Hay un buen punto hecho antes. () == [] también es igual a falso. Aunque me gusta cómo esta implementación lee el if not a: cubre todos los casos, si definitivamente está esperando una lista, su ejemplo debería ser suficiente. - Una estrella

"se rompe más fácilmente" ¿se necesita una cita? if not a se rompe cuando a es None - puedes deseo el mismo comportamiento para None y [], pero si tu explícitamente quiere comprobar si hay una lista vacía, if not a no hace eso. - scubbo

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

Respondido 09 Feb 19, 23:02

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 una prueba None y para la vacuidad 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 que 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 esperado

list is empty
list is empty
list has 3 elements

Respondido el 16 de diciembre de 19 a las 03:12

En mi humilde opinión, esta es la mejor respuesta. Aborda los matices con respecto a None y [] (una lista vacía) al realizar la prueba. - AltoÉxodo

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 verificar si hay una lista vacía, puede hacer esto:

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

Respondido 12 Oct 18, 05:10

Es posible que esto arroje una excepción, si a no es una lista y a no tiene metodo __len__ implementado. Yo recomendaria: if isinstance(obj, list): if len(obj) == 0: print '...' - Sven Kruger

@ SvenKrüger no. Operador and es vago en Python. Nada despues and se ejecutará si la condición anterior and Es falso. - ElmoVanKielmo

Si desea comprobar si una lista está vacía:

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

Si desea comprobar si todos los valores de la lista están vacíos. Sin embargo será True para una lista vacía:

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

Si desea usar ambos casos juntos:

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.

Respondido 12 Feb 20, 10:02

all (bool (x) para x en l) es Verdadero para una lista vacía - gberger

Incluso puedes intentar usar bool() como esto. Aunque es menos legible, seguramente es una forma concisa de realizar esto.

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

Me encanta esta forma porque la lista de verificación está vacía o no.

Muy práctico y útil.

Respondido el 25 de Septiembre de 20 a las 08:09

Para aquellos (como yo) que no sabían bool() convierte una variable de Python en un booleano para que pueda almacenar la veracidad o falsedad de un valor sin tener que utilizar una sentencia if. Creo que es menos legible que simplemente usar un condicional como la respuesta aceptada, pero estoy seguro de que hay otros buenos casos de uso para ello. - galeno largo

Esto se puede utilizar en una expresión y es más conciso. - qneill

La desventaja ocurre cuando a is None. Esto suele ser aceptable, pero es bueno tenerlo en cuenta. - lars p

Inspirándome en la solución de @dubiousjim, propongo usar una verificación general adicional de 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

respondido 29 mar '17, 03:03

Overbroad; esto es solo preguntar si una lista está vacía, no si algo es un iterable vacío. - picante

Si no estuviera contento con if a:, sería porque quería una excepción si a no era una especie de contenedor. (Siendo un iterable también permite iteradores, que no se pueden probar de manera útil para detectar la vacuidad). Arenque Davis

podríamos usar un simple if else:

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

Respondido 27 Jul 19, 19:07

-1 - Para evitar confusiones, no use palabras reservadas para los nombres de variables o puede obtener un comportamiento sorprendente la próxima vez que intente llamar, por ejemplo, "list ()" ... algo como "TypeError: 'list' object is no invocable "o algo así. - Sr. Maravilloso

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

un poco más práctico:

a.pop() if a else None

y versión más pura:

if a: a.pop() 

Respondido 05 Oct 19, 00:10

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 un tipo de secuencia (es una less pythonic camino):

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

def enquiry(list1): 
    if not list1: 
        return True
    else: 
        return False

# ––––––––––––––––––––––––––––––––

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.

Respondido 12 Feb 20, 11:02

¡Ha votado a favor también por mostrar cómo comprobar si no está vacío! Esto ayuda a cubrir el caso de uso opuesto pero igualmente importante: david frik

Tenga en cuenta que el segundo puede no funcionar con otros objetos de tipo de matriz común, como matrices numpy. - Alexis Drakopoulos

Gracias Alexis, lo tendré en cuenta. - andy fedoroff

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. Por estos, puede llamarlo muchas veces usando solo is_empty(any_structure).

Respondido el 20 de Septiembre de 17 a las 03:09

Su nombre is_empty sugiere que devuelve algo. Pero si lo hiciera, ese algo simplemente sería bool(any_structure), que deberías usar en su lugar (cuando tu necesitas un bool en absoluto). - Arenque Davis

¿Por qué queremos una variación de bool que (también) imprime mensajes en la salida estándar? - Arenque Davis

@DavisHerring Siempre tenemos dos opciones, primero es imprimir usando la función, otra es usar return bool variable. La elección es tuya. Escribo ambos para que puedas elegir entre ellos. - Vineet Jain

Una forma simple es verificar que la longitud sea igual a cero.

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

Respondido 12 Oct 18, 03:10

Desde python3 en adelante, puede 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

respondido 06 nov., 18:10

por favor, dé más explicaciones sobre cómo está funcionando sin escribir "si". - Ganeshdeshmukh

Esto no es pitónico ni un ejemplo completo. Además, crea una instancia de una lista vacía cada vez que se encuentra. No hagas esto. - Sr. Maravilloso

@MrWonderful no crea una instancia de una lista vacía cada vez. Solo verifica si la lista existente a está vacío o no. - Trecto

@MrWonderful, no entiendo lo que lo hace pythonic - Trecto

@ganeshdeshmukh si usa a==[] imprimirá verdadero en la terminal de Python si a está vacío. De lo contrario, se imprimirá Falso. Puede usar esto dentro de una condición if también como if(a==[]) - Trecto

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

Respondido el 06 de junio de 18 a las 20:06

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 lo suficientemente simple):

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

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

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

Por supuesto, haz no utilizan el bool in 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

Respondido 27 Jul 19, 19:07

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.