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 Strings.isNullOrEmpty de Guava.

Esto es lo que usaría para probar si una cadena es Ninguna 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 opuesto a probar si una cadena no es Ninguna NI Vacío NI Espacio en 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())

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

Las cadenas vacías son "falsas" (referencia de python 2 o python 3 ), 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 usar myString == "" . Consulte la documentación sobre Pruebas de valores de verdad para conocer otros valores que son falsos en contextos booleanos.

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.

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

Así que deberías usar:

 if not some_string:

o:

 if some_string:

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

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

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

Como prmatta publicado anteriormente, pero con error.

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

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

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"

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

¿Qué tal esto? Quizás no sea "la más elegante", pero parece bastante completa y clara:

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

Cuando esté leyendo el archivo por líneas y quiera determinar qué línea está vacía, asegúrese de usar .strip() , porque hay un carácter de nueva 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

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

Enfoque de código limpio

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

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

Nombres de variables descriptivos

Uno puede pensar que "empty_string" es un nombre de variable descriptivo. no lo 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 descriptivo se basa en su contexto. Tienes que pensar en cuál es la cadena vacía.

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

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 de análisis completo de 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 representar None sin 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 representa None con una cadena diferente a ""

 if csvfield == CSV_NONE: csvfield = None

No hay dudas sobre si este fragmento de código es correcto. Está bastante claro que hace lo que debe 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 les diría a los codificadores futuros que una cadena vacía siempre debe considerarse como None .

Esto se debe a que combina la lógica empresarial (Qué valor de CSV debe ser None ) con la implementación del código (Con qué estamos comparando realmente)

Tiene que haber una separación de preocupaciones entre los dos.

Respondiendo a @ 1290. Lo sentimos, no hay forma de formatear bloques en los comentarios. El valor None no es una cadena vacía en Python, y tampoco lo es (espacios). La respuesta de Andrew Clark es la correcta: if not myString . La respuesta de @rouble es específica de la aplicación y no responde a la pregunta del OP. Te meterás en 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 que no está en blanco.

Sin embargo, si debe tratar None y (espacios) como cadenas "en blanco", aquí hay 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 con los requisitos de @rouble sin romper el comportamiento bool esperado de las cadenas.

not str(myString)

Esta expresión es True para cadenas que están vacías. Las cadenas no vacías, Ninguno 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.

Si solo usas

 not var1

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

 var1 = '' not var1 > True var1 = False not var1 > True

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

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

Experimenté un poco con cadenas como '', '', '\n', etc. Quiero que isNotWhitespace sea verdadero si y solo si la variable foo es una cadena con al menos un carácter que no sea 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.

En caso de que esto sea útil para alguien, aquí hay una función rápida que construí 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).

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

De manera similar myString == "" y myString.__eq__("") pueden fallar si myString anula __eq__() y __ne__() .

Por alguna razón "" == myString también se deja engañar si myString anula __eq__() .

myString is "" y "" is myString son equivalentes. Ambos fallarán si myString no es realmente 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 que, en teoría, "" no está necesariamente internado y eso depende de la implementación.

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 al __eq__() 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 .

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

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

Además, comparar 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.

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

Para comparar el valor de cadena con valores Ninguno y valores NaN de DataFrame, aquí hay una solución de prueba completa

 import pandas as pd def isNotBlank(strVal: str) -> bool: if strVal is None or pd.isnull(strVal): return False return len(strVal.strip()) > 0 def isBlank(strVal: str) -> bool: return not isNotBlank(strVal) ############### Test Area ############### Test1 = None Test2 = pd.NaT Test3 = 'Test' Test4 = '' Test5 = ' ' print(isNotBlank(Test1)) print(isNotBlank(Test2)) print(isNotBlank(Test3)) print(isNotBlank(Test4)) print(isNotBlank(Test5)) ################# Output ################ # False # False # True # False # False

A continuación se muestra una solución elegante para cualquier número de espacios.

 def str_empty(s: str) -> bool: """Strip white space and count remaining characters.""" return True if len(s.strip()) < 1 else False s = ' ' str_empty(s) True

Si no está totalmente seguro de que su entrada es realmente una cadena, le recomendaría usar el enlace isinstance(object, classinfo) además, como se muestra en el ejemplo.

De lo contrario, las listas o un valor True bool también podrían evaluarse como True .

 <script type="text/javascript" src="//cdn.datacamp.com/dcl-react.js.gz"></script> <div data-datacamp-exercise data-lang="python"> <code data-type="sample-code"> def test_string(my_string): if isinstance(my_string, str) and my_string: print("It's a me, String! -> " + my_string) else: print("Nope. No, String") def not_fully_test_string(my_string): if my_string: print("It's a me, String??? -> " + str(my_string)) else: print("Nope. No, String") print("Testing String:") test_string("") test_string(True) test_string(["string1", "string2"]) test_string("My String") test_string(" ") print("\nTesting String or not?") not_fully_test_string("") not_fully_test_string(True) not_fully_test_string(["string1", "string2"]) not_fully_test_string("My String") not_fully_test_string(" ") </code> </div>

Puede echar un vistazo a esto Asignación de valor vacío o cadena 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 ...