Cómo comprobar si una cadena es de espacios en blanco en Python

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena está formada completamente por caracteres de espacio en blanco en Python. El laboratorio comienza definiendo caracteres de espacio en blanco comunes, como espacio, tabulación, salto de línea, retorno de carro, tabulación vertical y avance de página. Luego, crearás un script de Python para demostrar estos caracteres y sus efectos en el formato de texto.

El laboratorio te guiará en el uso del método isspace() para determinar si una cadena contiene solo espacios en blanco. Finalmente, diferenciará entre cadenas que contienen espacios en blanco y cadenas vacías, destacando la importancia de entender estas distinciones en la programación en Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python(("Python")) -.-> python/FileHandlingGroup(["File Handling"]) python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python/BasicConceptsGroup -.-> python/strings("Strings") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") python/FileHandlingGroup -.-> python/file_operations("File Operations") subgraph Lab Skills python/strings -.-> lab-559582{{"Cómo comprobar si una cadena es de espacios en blanco en Python"}} python/build_in_functions -.-> lab-559582{{"Cómo comprobar si una cadena es de espacios en blanco en Python"}} python/file_operations -.-> lab-559582{{"Cómo comprobar si una cadena es de espacios en blanco en Python"}} end

Definir Caracteres de Espacio en Blanco

En este paso, aprenderás sobre los caracteres de espacio en blanco en Python. Los caracteres de espacio en blanco son aquellos que representan un espacio vacío. Son importantes en la programación porque afectan cómo se interpreta y muestra el código. Comprender los espacios en blanco es crucial para escribir código Python limpio y legible.

Los caracteres de espacio en blanco comunes incluyen:

Espacio ( ): El carácter de espacio en blanco más común, utilizado para separar palabras y declaraciones.
Tabulación (\t): Utilizada para la indentación, normalmente representa cuatro espacios.
Salto de línea (\n): Utilizado para indicar el final de una línea.
Retorno de carro (\r): Utilizado en sistemas antiguos para devolver el cursor al inicio de la línea.
Tabulación vertical (\v): Menos utilizado, pero aún es un carácter de espacio en blanco.
Avance de página (\f): Utilizado para avanzar a la siguiente página en la impresión.

Vamos a crear un script de Python para demostrar estos caracteres.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado whitespace_demo.py en el directorio ~/project.
```
touch ~/project/whitespace_demo.py
```

Abre el archivo whitespace_demo.py en el editor y agrega el siguiente contenido:

## Demonstrating whitespace characters

space_char = " "
tab_char = "\t"
newline_char = "\n"
carriage_return_char = "\r"
vertical_tab_char = "\v"
form_feed_char = "\f"

print("This", space_char, "is", space_char, "separated", space_char, "by", space_char, "spaces.")
print("This\tis\tseparated\tby\ttabs.")
print("This" + newline_char + "is" + newline_char + "on" + newline_char + "multiple" + newline_char + "lines.")
print("This" + carriage_return_char + "will overwrite the beginning of the line.")
print("Vertical" + vertical_tab_char + "Tab")
print("Form" + form_feed_char + "Feed")

Este script define variables para cada carácter de espacio en blanco y luego las utiliza en declaraciones print() para demostrar sus efectos.

Ejecuta el script utilizando el comando python:
```
python ~/project/whitespace_demo.py
```
Deberías ver una salida similar a la siguiente:
```
This   is   separated   by   spaces.
This    is      separated       by      tabs.
This
is
on
multiple
lines.
 will overwrite the beginning of the line.
Vertical Tab
Form Feed
```
Observa cómo cada carácter de espacio en blanco afecta el formato de la salida. El carácter de salto de línea crea saltos de línea, y el carácter de tabulación crea espaciado horizontal. El retorno de carro sobrescribe el inicio de la línea. Los caracteres de tabulación vertical y avance de página pueden no ser visibles dependiendo de tu terminal.

Usar el Método `isspace()`

En este paso, aprenderás cómo usar el método isspace() en Python para verificar si una cadena está formada solo por caracteres de espacio en blanco. Este método es muy útil para validar la entrada del usuario o limpiar datos.

El método isspace() es un método incorporado de cadenas que devuelve True si todos los caracteres de la cadena son caracteres de espacio en blanco (espacio, tabulación, salto de línea, etc.) y hay al menos un carácter. De lo contrario, devuelve False.

Vamos a crear un script de Python para demostrar el método isspace().

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado isspace_demo.py en el directorio ~/project.
```
touch ~/project/isspace_demo.py
```

Abre el archivo isspace_demo.py en el editor y agrega el siguiente contenido:

## Demonstrating the isspace() method

string1 = "   "  ## Contains only spaces
string2 = "\t\n"  ## Contains tabs and newlines
string3 = "  abc  "  ## Contains spaces and letters
string4 = ""  ## Empty string
string5 = "123" ## Contains numbers

print(f"'{string1}'.isspace(): {string1.isspace()}")
print(f"'{string2}'.isspace(): {string2.isspace()}")
print(f"'{string3}'.isspace(): {string3.isspace()}")
print(f"'{string4}'.isspace(): {string4.isspace()}")
print(f"'{string5}'.isspace(): {string5.isspace()}")

Este script define varias cadenas con diferentes combinaciones de caracteres de espacio en blanco y no espacios en blanco. Luego, utiliza el método isspace() para verificar si cada cadena está formada solo por caracteres de espacio en blanco.

Ejecuta el script utilizando el comando python:
```
python ~/project/isspace_demo.py
```
Deberías ver una salida similar a la siguiente:
```
'   '.isspace(): True
'
'.isspace(): True
'  abc  '.isspace(): False
''.isspace(): False
'123'.isspace(): False
```
Como puedes ver, isspace() devuelve True solo para cadenas que contienen solo caracteres de espacio en blanco y no están vacías.

Diferenciar de Cadenas Vacías

En este paso, aprenderás a diferenciar entre cadenas que contienen solo espacios en blanco y cadenas vacías en Python. Es importante entender la diferencia porque isspace() se comporta de manera diferente para cadenas vacías.

Como aprendiste en el paso anterior, el método isspace() devuelve True si todos los caracteres de una cadena son caracteres de espacio en blanco y la cadena no está vacía. Para una cadena vacía (una cadena sin caracteres), isspace() devuelve False.

Vamos a modificar el script isspace_demo.py del paso anterior para enfatizar esta diferencia.

Abre el archivo isspace_demo.py en el editor de VS Code en el directorio ~/project.

Modifica el script para incluir una comprobación más explícita de cadenas vacías:

## Demonstrating the isspace() method and empty strings

string1 = "   "  ## Contains only spaces
string2 = ""  ## Empty string

print(f"'{string1}'.isspace(): {string1.isspace()}")
print(f"'{string2}'.isspace(): {string2.isspace()}")

if string2:
    print("string2 is not empty")
else:
    print("string2 is empty")

if string1.isspace():
    print("string1 contains only whitespace")
else:
    print("string1 does not contain only whitespace")

Este script ahora incluye una declaración if para verificar si string2 está vacía. También verifica si string1 contiene solo caracteres de espacio en blanco.

Ejecuta el script utilizando el comando python:
```
python ~/project/isspace_demo.py
```
Deberías ver una salida similar a la siguiente:
```
'   '.isspace(): True
''.isspace(): False
string2 is empty
string1 contains only whitespace
```
Esta salida muestra claramente que isspace() devuelve False para una cadena vacía, y la declaración if identifica correctamente a string2 como una cadena vacía.

Resumen

En este laboratorio, aprendiste sobre los caracteres de espacio en blanco en Python, que son caracteres que representan espacios vacíos y afectan la interpretación y visualización del código. El laboratorio cubrió caracteres de espacio en blanco comunes, como el espacio, la tabulación, el salto de línea, el retorno de carro, la tabulación vertical y la alimentación de formulario.

Creadiste un script de Python llamado whitespace_demo.py para demostrar estos caracteres definiendo variables para cada uno y usándolos en declaraciones print() para ilustrar sus efectos en el formato y la salida del texto.