¿Cómo verificar si la cadena está vacía?


1421

¿Python tiene algo así como una variable de cadena vacía donde puedes hacer:

if myString == string.empty:

De todos modos, ¿cuál es la forma más elegante de verificar los valores de cadena vacíos? Encuentro que la codificación dura ""cada vez para verificar una cadena vacía no es tan buena.


2
¿Cómo ""no es tan bueno?
NoName

Respuestas:


2117

Las cadenas vacías son "falsas", lo que significa que se consideran falsas en un contexto booleano, por lo que puede hacer esto:

if not myString:

Esta es la forma preferida si sabe que su variable es una cadena. Si su variable también podría ser de otro tipo, entonces debería usarla myString == "". Consulte la documentación sobre Pruebas de valor de verdad para ver otros valores que son falsos en contextos booleanos.


183
Tenga cuidado, ya que muchas otras cosas son falsas también.
Ignacio Vazquez-Abrams

99
Nunca he oído hablar del término falso antes. ¿Significa que devuelve falso?
Joan Venge

41
@Joan: se evalúa como falso en un contexto booleano.
Ignacio Vazquez-Abrams

54
PO quiere saber si la variable es una cadena vacía, pero también se podría entrar en el if not myString:bloque si myStringeran None, 0, Falseetc Así que si usted no está seguro de qué tipo myStringes, se debe utilizar if myString == "":para determinar si se trata de una cadena vacía en lugar de algún otro valor falso.
Andrew Clark

15
@AndrewClark, para tal caso, en lugar de una cadena de if myString == ...expresiones, podríamos usar if myString in (None, '')o por @Bartek,if myString in (None, '') or not myString.strip()
Stew

414

De PEP 8 , en la sección "Recomendaciones de programación" :

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

Entonces deberías usar:

if not some_string:

o:

if some_string:

Solo para aclarar, las secuencias se evalúan en Falseo Trueen un contexto booleano si están vacías o no. No son iguales a Falseo True.


24
¡Genial que hayas incluido referencias al PEP!
Felix

3
PD: En defensa del PEP, uno podría argumentar que decir " x es falso " (minúscula falso ) ya significa eso, en lugar de significado x == False. Pero en mi humilde opinión, la aclaración sigue siendo bienvenida dada la audiencia objetivo.
MestreLion

234

La forma más elegante probablemente sería simplemente verificar si es verdadero o falso, por ejemplo:

if not my_string:

Sin embargo, es posible que desee quitar espacios en blanco porque:

 >>> bool("")
 False
 >>> bool("   ")
 True
 >>> bool("   ".strip())
 False

Sin embargo, probablemente debería ser un poco más explícito en esto, a menos que sepa con certeza que esta cadena ha pasado algún tipo de validación y es una cadena que se puede probar de esta manera.


88

No probaría nada antes de desnudarme. Además, usaría el hecho de que las cadenas vacías son False (o Falsy). Este enfoque es similar a StringUtils.isBlank de Apache o Strings.isNullOrEmpty de Guava

Esto es lo que usaría para probar si una cadena es Ninguno O Vacío O En Blanco:

def isBlank (myString):
    if myString and myString.strip():
        #myString is not None AND myString is not empty or blank
        return False
    #myString is None OR myString is empty or blank
    return True

Y, exactamente lo contrario para probar si una cadena no es Ninguna NOR Vacío NOR Blanco:

def isNotBlank (myString):
    if myString and myString.strip():
        #myString is not None AND myString is not empty or blank
        return True
    #myString is None OR myString is empty or blank
    return False

Formas más concisas del código anterior:

def isBlank (myString):
    return not (myString and myString.strip())

def isNotBlank (myString):
    return bool(myString and myString.strip())

¿por qué no if mystring and not mystring.strip()?
Migol

1
¿Cómo es diferente de string and not string.isspace()?
Andrea Corbellini

77
Más conciso para quienes se preocupan por tales cosas: def isBlank(s): return not (s and s.strip())y def isNotBlank(s): return s and s.strip().
Carl

49

Una vez escribí algo similar a la respuesta de Bartek y javascript inspirado:

def is_not_blank(s):
    return bool(s and s.strip())

Prueba:

print is_not_blank("")    # False
print is_not_blank("   ") # False
print is_not_blank("ok")  # True
print is_not_blank(None)  # False

¿Por qué no simplementereturn bool(s.strip())
anilbey

1
AttributeError: 'NoneType' object has no attribute 'strip'
bóveda

29

La única forma realmente sólida de hacerlo es la siguiente:

if "".__eq__(myString):

Todas las demás soluciones tienen posibles problemas y casos extremos donde la verificación puede fallar.

len(myString)==0puede fallar si myStringes un objeto de una clase que hereda stry anula el __len__()método.

Del mismo modo myString == ""y myString.__eq__("")puede fallar si myStringanula __eq__()y __ne__().

Por alguna razón, "" == myStringtambién se deja engañar si se myStringanula __eq__().

myString is ""y "" is myStringson equivalentes Ambos fallarán si myStringno es realmente una cadena, sino una subclase de cadena (ambos volverán False). Además, dado que son comprobaciones de identidad, la única razón por la que funcionan es porque Python usa String Pooling (también llamado String Internment) que usa la misma instancia de una cadena si está internada (ver aquí: ¿Por qué comparar cadenas usando '= = 'o' es 'a veces produce un resultado diferente? ). Y ""es internado desde el principio en CPython

El gran problema con la verificación de identidad es que String Internment es (por lo que pude encontrar) que no está estandarizado qué cadenas están internadas. Eso significa que, en teoría, ""no es necesario internado y que depende de la implementación.

La única manera de hacer esto que realmente no puede ser engañado es el que se menciona al principio: "".__eq__(myString). Como esto llama explícitamente al __eq__()método de la cadena vacía, no se puede engañar anulando ningún método en myString y funciona sólidamente con subclases de str.

También confiar en la falsedad de una cadena podría no funcionar si el objeto anula su __bool__()método.

Este no es solo un trabajo teórico, sino que podría ser relevante en el uso real, ya que he visto subclases de bibliotecas y marcos strantes y el uso myString is ""podría devolver un resultado incorrecto allí.

Además, comparar cadenas usando isen general es una trampa bastante malvada, ya que funcionará correctamente a veces, pero no en otras, ya que la agrupación de cadenas sigue reglas bastante extrañas.

Dicho esto, en la mayoría de los casos, todas las soluciones mencionadas funcionarán correctamente. Esta publicación es principalmente trabajo académico.


2
@simpleuser, por supuesto, tienes razón. En el mundo real, está completamente bien usar la falsedad de la cadena o compararla con una cadena vacía. Esta respuesta aquí es exagerada a propósito.
Dakkaron

realmente, usa eq_ ?
Slboat

trabajando increíble, gracias!
eugene.polschikov

14

Prueba de cadena vacía o en blanco (forma más corta):

if myString.strip():
    print("it's not an empty or blank string")
else:
    print("it's an empty or blank string")

77
Si myString = None, provocará una excepción. Mejor use la respuesta de
@vault

9

Si desea diferenciar entre cadenas vacías y nulas, sugeriría usar if len(string), de lo contrario, sugeriría usar simplemente if stringcomo otros han dicho. Sin embargo, la advertencia sobre las cadenas llenas de espacios en blanco todavía se aplica, así que no te olvides strip.


No sé por qué querrías evitar usar "", a menos que afecte el rendimiento de alguna manera, pero prefiero tu respuesta a la que tiene miles de votos, ya que es menos confuso. Sin embargo, quería señalar que una lista vacía también es falsa, aparentemente.
Brōtsyorfuzthrāx

7

if stringname:da un falsecuando la cadena está vacía. Supongo que no puede ser más simple que esto.


7

Encuentro que la "" codificación (sic) "" cada vez para verificar una cadena vacía no es tan buena.

Enfoque de código limpio

Hacer esto: foo == ""es una muy mala práctica. ""Es un valor mágico. Nunca debe verificar los valores mágicos (más comúnmente conocidos como números mágicos )

Lo que debe hacer es compararlo con un nombre de variable descriptivo.

Nombres descriptivos de variables

Uno puede pensar que "cadena_vacía" es un nombre de variable descriptivo. No es .

Antes de ir y hacer empty_string = ""y pensar que tiene un gran nombre de variable para comparar. Esto no es lo que significa "nombre de variable descriptivo".

Un buen nombre de variable descriptiva se basa en su contexto. Usted tiene que pensar en lo que la cadena vacía es .

  • De dónde viene.
  • ¿Por qué está ahí?
  • ¿Por qué necesitas verificarlo?

Ejemplo de campo de formulario simple

Está creando un formulario donde un usuario puede ingresar valores. Desea verificar si el usuario escribió algo o no.

Un buen nombre de variable puede ser not_filled_in

Esto hace que el código sea muy legible

if formfields.name == not_filled_in:
    raise ValueError("We need your name")

Ejemplo completo de análisis CSV

Está analizando archivos CSV y desea que la cadena vacía se analice como None

(Dado que CSV está completamente basado en texto, no puede representarse Nonesin usar palabras clave predefinidas)

Un buen nombre de variable puede ser CSV_NONE

Esto hace que el código sea fácil de cambiar y adaptar si tiene un nuevo archivo CSV que se representa Nonecon otra cadena que no sea""

if csvfield == CSV_NONE:
    csvfield = None

No hay preguntas sobre si este código es correcto. Está bastante claro que hace lo que debería hacer.

Compara esto con

if csvfield == EMPTY_STRING:
    csvfield = None

La primera pregunta aquí es: ¿por qué la cadena vacía merece un tratamiento especial?

Esto le diría a los futuros codificadores que una cadena vacía siempre debe considerarse como None.

Esto se debe a que combina la lógica empresarial (cuál debería ser el valor CSV None) con la implementación del código (con qué nos estamos comparando)

Es necesario que haya una separación de preocupación entre los dos.


1
¿Realmente hay que meterse en tantos problemas para evitar un ""? En el contexto de la comparación, ¿qué más podría significar una cadena en blanco?

Mientras escribo en mi respuesta, CSV no puede representar nulo sin usar una cadena. Si no tiene contexto, ¡felicidades! La mayoría del código no lo es.
firelynx

2
¿Dices que "not_filled_in" es más descriptivo que "empty_string"? Yo digo que estás drogado.
Tuncay Göncüoğlu

@ TuncayGöncüoğlu "Cadena vacía" no describe para qué sirve la instrucción if.
firelynx

55
No estaría de acuerdo con esa respuesta. Los números mágicos son malos, eso tiene sentido. Valores mágicos en general también. Pero ""no es un valor mágico, mismo que True, Falseo Noneno son valores mágicos.
Dakkaron

6
a = ''
b = '   '
a.isspace() -> False
b.isspace() -> True

1
Realmente no entiendo lo que gana esta solución. La pregunta es sobre probar si una cadena está vacía. Si configura a='a', obtendría a.isspace() -> False, pero ano sería en esa cuenta una cadena vacía.
Adrian Keister

5

¿Qué tal esto? Quizás no sea "el más elegante", pero parece bastante completo y claro:

if (s is None) or (str(s).strip()==""): // STRING s IS "EMPTY"...

Para la mayoría de los propósitos, una cadena que contiene espacios en blanco no está "vacía".
Chris Johnson

¿Asumo que no quieres decir nada más que espacios en blanco? ¿Te refieres a mi uso de strip ()? ¡Para la mayoría de los propósitos eso ESTÁ vacío! Es ridículamente común combinar algo como s.trim (). IsEmpty ()
BuvinJ

Hola @Chris Johnson, ¿viste que la mayoría de las respuestas aquí también usan strip ()? ¿Nos votó a todos, o solo a mí?
BuvinJ

4

En respuesta a @ 1290. Lo sentimos, no hay forma de formatear bloques en los comentarios. El Nonevalor no es una cadena vacía en Python, y tampoco lo es (espacios). La respuesta de Andrew Clark es el correcto: if not myString. La respuesta de @rouble es específica de la aplicación y no responde la pregunta del OP. Tendrás problemas si adoptas una definición peculiar de lo que es una cadena "en blanco". En particular, el comportamiento estándar es que str(None)produce 'None'una cadena no en blanco.

Sin embargo, si debe tratar Noney (espacios) como cadenas "en blanco", esta es una mejor manera:

class weirdstr(str):
    def __new__(cls, content):
        return str.__new__(cls, content if content is not None else '')
    def __nonzero__(self):
        return bool(self.strip())

Ejemplos:

>>> normal = weirdstr('word')
>>> print normal, bool(normal)
word True

>>> spaces = weirdstr('   ')
>>> print spaces, bool(spaces)
    False

>>> blank = weirdstr('')
>>> print blank, bool(blank)
 False

>>> none = weirdstr(None)
>>> print none, bool(none)
 False

>>> if not spaces:
...     print 'This is a so-called blank string'
... 
This is a so-called blank string

Cumple los requisitos de @rouble sin romper el boolcomportamiento esperado de las cadenas.


python -c "if (str(None) == 'None'): print ('OMG, WHY ??')"
Yordan Georgiev

3

Me parece elegante, ya que se asegura de que sea una cuerda y comprueba su longitud:

def empty(mystring):
    assert isinstance(mystring, str)
    if len(mystring) == 0:
        return True
    else:
        return False

Advertencia, las afirmaciones están pensadas como una herramienta de depuración y se optimizan si pasas el -Omarcador o configuras la PYTHONOPTIMIZEvariable env.
SilentVoid

2

Otra forma fácil podría ser definir una función simple:

def isStringEmpty(inputString):
    if len(inputString) == 0:
        return True
    else:
        return False

3
la respuesta del cardamomo es más completa si queremos verificar si la entrada es una cadena o no
tanzil

1
not str(myString)

Esta expresión es verdadera para las cadenas que están vacías. Las cadenas no vacías, Ninguna y los objetos que no son cadenas producirán Falso, con la advertencia de que los objetos pueden anular __str__ para frustrar esta lógica al devolver un valor falso.




0

Cuando esté leyendo un archivo por líneas y quiera determinar qué línea está vacía, asegúrese de usarla .strip(), porque hay un nuevo carácter de línea en la línea "vacía":

lines = open("my_file.log", "r").readlines()

for line in lines:
    if not line.strip():
        continue

    # your code for non-empty lines

0
str = ""
if not str:
   print "Empty String"
if(len(str)==0):
   print "Empty String"

0

Si solo usas

not var1 

no es posible diferenciar una variable que es booleana Falsede una cadena vacía '':

var1 = ''
not var1
> True

var1 = False
not var1
> True

Sin embargo, si agrega una condición simple a su script, la diferencia se hace:

var1  = False
not var1 and var1 != ''
> True

var1 = ''
not var1 and var1 != ''
> False

0

En caso de que esto sea útil para alguien, aquí hay una función rápida que desarrollé para reemplazar cadenas en blanco con N / A en listas de listas (python 2).

y = [["1","2",""],["1","4",""]]

def replace_blank_strings_in_lists_of_lists(list_of_lists):
    new_list = []
    for one_list in list_of_lists:
        new_one_list = []
        for element in one_list:
            if element:
                new_one_list.append(element)
            else:
                new_one_list.append("N/A")
        new_list.append(new_one_list)
    return new_list


x= replace_blank_strings_in_lists_of_lists(y)
print x

Esto es útil para publicar listas de listas en una base de datos mysql que no acepta espacios en blanco para ciertos campos (campos marcados como NN en el esquema. En mi caso, esto se debió a una clave primaria compuesta).


-1

Experimenté un poco con cadenas como '', '', '\ n', etc. Quiero que isNotWhitespace sea True si y solo si la variable foo es una cadena con al menos un carácter que no es un espacio en blanco. Estoy usando Python 3.6. Esto es lo que terminé con:

isWhitespace = str is type(foo) and not foo.strip()
isNotWhitespace = str is type(foo) and not not foo.strip()

Envuelva esto en una definición de método si lo desea.


-3

Como prmatta publicado anteriormente, pero con error.

def isNoneOrEmptyOrBlankString (myString):
    if myString:
        if not myString.strip():
            return True
        else:
            return False
    return False

Sólo probado: Sus código vuelve True para ""y " "y False para "a"(tal y como se esperaba). Su código devuelve lo mismo, excepto por la cadena vacía que devuelve True, lo que no debería.
AbcAeffchen

sry demasiado cansado: su código devuelve False para la cadena vacía.
AbcAeffchen

Este código está mal Devuelve False si una cadena está vacía o ninguna.
rublo
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.