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

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.

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.

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.

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

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

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.

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

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.

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

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.

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

¿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"...

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.

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

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

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

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.

Puede echar un vistazo a esta Asignación de valor o cadena vacía en Python

Se trata de comparar cadenas que están vacías. Entonces, en lugar de probar el vacío con not, puede probar si su cadena es igual a una cadena vacía con ""la cadena vacía ...

Para aquellos que esperan un comportamiento como Apache StringUtils.isBlank o Guava Strings.isNullOrEmpty :

if mystring and mystring.strip():
    print "not blank string"
else:
    print "blank string"

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

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

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

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

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.

Como prmatta publicado anteriormente, pero con error.

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