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

¿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 valores de cadena vacíos? Encuentro codificación difícil "" cada vez que comprueba una cadena vacía no es tan buena.

Las cadenas vacías son “falsas” (pitón 2 o pitón 3 referencia), lo que significa que se consideran falsos 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 usar:

if myString == "":

Consulte la documentación sobre Pruebas de valor de verdad para otros valores que son falsos en contextos booleanos.

De PEP 8en el Apartado “Recomendaciones de programación”:

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

Así que deberías usar:

if not some_string:

o:

if some_string:

Solo para aclarar, las secuencias son evaluado a False o True en un contexto booleano si están vacíos o no. Ellos son no es igual a False o 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 eliminar los 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 esté seguro de que esta cadena ha pasado algún tipo de validación y es una cadena que se puede probar de esta manera.

Probaría la nada antes de desnudarme. Además, usaría el hecho de que las cadenas vacías son falsas (o falsas). Este enfoque es similar a StringUtils.isBlank de Apache o Cuerdas de guayaba.isNullOrEmpty

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

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

Y, exactamente lo opuesto a probar si una cadena no es Ninguna NI Vacío NI Espacio en blanco:

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 not s.isspace())

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 hacer esto es la siguiente:

if "".__eq__(myString):

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

• len(myString) == 0 puede fallar si myString es un objeto de una clase que hereda de str y anula el __len__() método.

• myString == "" y myString.__eq__("") puede fallar si myString anula __eq__() y __ne__().

• "" == myString también se deja engañar si myString anula __eq__().

• myString is "" y "" is myString son equivalentes. Ambos fracasarán si myString no es en realidad una cadena sino una subclase de cadena (ambos devolverán False). Además, dado que son verificaciones 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 ‘is’ a veces producen un resultado diferente?). Y "" está internado desde el principio en CPython

  El gran problema con la verificación de identidad es que String Internment es (hasta donde pude encontrar) que no está estandarizado qué cadenas están internadas. Eso significa, teóricamente "" no es necesario internado y eso depende de la implementación.

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

• Confiar en la falsedad de una cadena puede no funcionar si el objeto anula __bool__().

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

Este no es solo un trabajo teórico, sino que en realidad podría ser relevante en el uso real, ya que he visto subclases de marcos y bibliotecas. str antes y usando myString is "" podría devolver una salida incorrecta allí.

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

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