python - color - plotly ylab

¿La forma más elegante de verificar si la cadena está vacía en Python?

Question

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

if myString == string.empty:

Independientemente de cuál sea la forma más elegante de verificar los valores de cadena vacía? Me parece que la codificación "" cada vez que se comprueba una cadena vacía no es tan buena.

Answer 1

Encuentro hardcoding (sic) "" cada vez que se comprueba que una cadena vacía no es tan buena.

Código limpio

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

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

Nombres de variables descriptivas

Uno puede pensar que "empty_string" es un nombre de variable descriptivo. No lo es

Antes de ir a hacer empty_string = "" y cree que tiene un gran nombre de variable con el que comparar. Esto no es lo que significa "nombre de variable descriptivo".

Un buen nombre de variable descriptiva se basa en su contexto. Tienes que pensar en qué es la cadena vacía.

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

Ejemplo de campo de formulario simple

Está creando un formulario donde un usuario puede introducir valores. Quieres comprobar 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 CSV completo

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 preguntas sobre si esta pieza de código es correcta. Es 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 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 (qué valor CSV debe ser None ) con la implementación del código (con qué estamos comparando)

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

Answer 2

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

Answer 3

Como prmatta publicado anteriormente, pero con error.

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

Answer 4

Cuando esté leyendo archivo por líneas y desee determinar qué línea está vacía, asegúrese de utilizar .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

Answer 5

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

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

Así que debes 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 .

Answer 6

En mi experiencia, las pruebas para "" no siempre funcionan. Estas simples pruebas siempre me han funcionado:

if MyString == ''None''

o

if MyString != ''None''

Leyendo una hoja de cálculo de Excel. Quiero detenerme cuando una columna se vacía usando el siguiente bucle while:

while str(MyString) != ''None'':

Answer 7

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

if not my_string:

Sin embargo, es posible que desee quitar el espacio 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 a ciencia cierta que esta cadena ha pasado algún tipo de validación y es una cadena que se puede probar de esta manera.

Answer 8

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

if not myString:

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

Answer 9

O bien lo siguiente

foo is ''''

o incluso

empty = ''''
foo is empty

Answer 10

Probaría la unicidad 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ía 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 a probar si una cadena no es Ninguna NOR Vacía NOR 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())

Answer 11

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

Answer 12

Puede echar un vistazo a esta Asignación de valores vacíos o cadenas 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 ...

Answer 13

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 ninguno 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. Tendrá problemas si adopta 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", 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 con los requisitos de @rouble sin romper el comportamiento esperado de las cadenas.

Answer 14

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 otros lo han dicho. Sin embargo, la advertencia sobre las cuerdas llenas de espacios en blanco todavía se aplica, así que no olvides strip .

Answer 15

Si solo usas

not var1

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

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

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

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

Answer 16

Una vez escribí algo similar a la respuesta de Bartek y se inspiró en javascript:

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

Prueba:

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

Answer 17

para aquellos que esperan un comportamiento como el apache StringUtils.isBlank o Guava Strings.isNullOrEmpty :

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

Answer 18

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

Answer 19

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

Answer 20

if my_string is '''':

No he notado esa combinación particular en ninguna de las respuestas. Busqué

is ''''

En las respuestas previas a la publicación.

 if my_string is '''': print (''My string is EMPTY'') # **footnote

Creo que esto es a lo que intentaba llegar el póster original ... algo que se lee lo más cerca posible del inglés y sigue prácticas de programación sólidas.

if my_string is '''':
print(''My string is EMPTY'')
else:
print(f''My string is {my_string}'')

Personaje por personaje Creo que esta solución es buena.

Noté que None ha entrado en la discusión, así que agregando eso y compactando más obtenemos:

if my_string is '''': print(''My string is Empty'')
elif my_string is None : print(''My string.... isn/'t'')
else: print(f''My string is {my_string}'')

Answer 21

not str(myString)

Esta expresión es verdadera para las 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 devolviendo un valor falso.

Answer 22

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