Cómo comprobar si una cadena es vacía en Python

Introducción

En este laboratorio (lab), aprenderás cómo comprobar si una cadena (string) está vacía en Python. El laboratorio comienza presentando el concepto de cadenas vacías, que son cadenas que no contienen caracteres y se representan con comillas simples ('') o comillas dobles (""). Crearás e imprimirás cadenas vacías utilizando tanto comillas simples como dobles, verificando su tipo como str.

A continuación, el laboratorio te guiará en el uso de la función len() para determinar la longitud de una cadena y en la evaluación de cadenas como valores booleanos para comprobar si están vacías. Estos métodos proporcionan formas prácticas de identificar y manejar cadenas vacías en tu código Python.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/ControlFlowGroup(["Control Flow"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/BasicConceptsGroup -.-> python/variables_data_types("Variables and Data Types") python/BasicConceptsGroup -.-> python/strings("Strings") python/BasicConceptsGroup -.-> python/booleans("Booleans") python/ControlFlowGroup -.-> python/conditional_statements("Conditional Statements") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") subgraph Lab Skills python/variables_data_types -.-> lab-559577{{"Cómo comprobar si una cadena es vacía en Python"}} python/strings -.-> lab-559577{{"Cómo comprobar si una cadena es vacía en Python"}} python/booleans -.-> lab-559577{{"Cómo comprobar si una cadena es vacía en Python"}} python/conditional_statements -.-> lab-559577{{"Cómo comprobar si una cadena es vacía en Python"}} python/build_in_functions -.-> lab-559577{{"Cómo comprobar si una cadena es vacía en Python"}} end

Aprende sobre cadenas vacías

En este paso, aprenderás sobre las cadenas vacías en Python. Una cadena vacía es simplemente una cadena que no contiene caracteres. Se representa con dos comillas simples ('') o dos comillas dobles (""). Comprender las cadenas vacías es crucial porque a menudo se utilizan como valores iniciales para variables o como una forma de representar la ausencia de datos.

Comencemos creando una cadena vacía utilizando comillas simples:

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

Agrega el siguiente código al archivo empty_string.py:

## Assign an empty string to a variable
empty_string = ''

## Print the empty string
print(empty_string)

## Check the type of the variable
print(type(empty_string))

Guarda el archivo.
Abre la terminal en VS Code.
Ejecuta el script utilizando el comando python:
```
python empty_string.py
```
Deberías ver la siguiente salida:
```
<class 'str'>
```
La primera línea está vacía porque imprimimos una cadena vacía. La segunda línea confirma que la variable empty_string es de tipo str (cadena).

Ahora, creemos una cadena vacía utilizando comillas dobles:

Modifica el archivo empty_string.py para usar comillas dobles en lugar de comillas simples:

## Assign an empty string to a variable
empty_string = ""

## Print the empty string
print(empty_string)

## Check the type of the variable
print(type(empty_string))

Guarda el archivo.
Ejecuta el script nuevamente:
```
python empty_string.py
```
La salida será la misma:
```
<class 'str'>
```
Esto demuestra que tanto las comillas simples como las comillas dobles se pueden utilizar para crear cadenas vacías en Python.

Las cadenas vacías son útiles en diversos escenarios. Por ejemplo, podrías utilizar una cadena vacía para inicializar una variable que almacenará más adelante la entrada del usuario, o para representar un valor faltante en un conjunto de datos. En los siguientes pasos, aprenderás cómo comprobar la longitud de una cadena y cómo se evalúan las cadenas vacías como valores booleanos.

Utiliza `len()` para comprobar la longitud

En este paso, aprenderás cómo utilizar la función len() en Python para determinar la longitud de una cadena (string). La función len() devuelve el número de caracteres en una cadena. Esta es una operación fundamental cuando se trabaja con cadenas, ya que te permite validar la entrada, manipular texto y realizar diversas otras tareas.

Comencemos comprobando la longitud de una cadena vacía:

Abre el archivo empty_string.py en el directorio ~/project que creaste en el paso anterior.

Modifica el código para utilizar la función len() y comprobar la longitud de la cadena vacía:

## Assign an empty string to a variable
empty_string = ''

## Check the length of the empty string
length = len(empty_string)

## Print the length
print(length)

Guarda el archivo.
Ejecuta el script utilizando el comando python:
```
python empty_string.py
```
Deberías ver la siguiente salida:
```
0
```
Esto confirma que la longitud de una cadena vacía es 0.

Ahora, comprobemos la longitud de una cadena no vacía:

Modifica el archivo empty_string.py para asignar una cadena no vacía a la variable empty_string:

## Assign a non-empty string to a variable
empty_string = "Hello, LabEx!"

## Check the length of the string
length = len(empty_string)

## Print the length
print(length)

Guarda el archivo.
Ejecuta el script nuevamente:
```
python empty_string.py
```
Deberías ver la siguiente salida:
```
13
```
La longitud de la cadena "Hello, LabEx!" es 13, incluyendo el espacio y el signo de exclamación.

La función len() se puede utilizar con cualquier cadena, independientemente de su contenido. Es una herramienta versátil para trabajar con datos de texto en Python. En el siguiente paso, aprenderás cómo se evalúan las cadenas vacías como valores booleanos en Python.

Evaluación como booleano

En este paso, aprenderás cómo se evalúan las cadenas vacías como valores booleanos en Python. En Python, una cadena vacía se considera "falsy" (falsa), lo que significa que cuando se utiliza en un contexto booleano (como en una declaración if), se evalúa como False. Por otro lado, las cadenas no vacías se consideran "truthy" (verdaderas) y se evalúan como True. Comprender este comportamiento es esencial para escribir declaraciones condicionales que manejen correctamente los valores de cadena.

Comencemos probando una cadena vacía en una declaración if:

Abre el archivo empty_string.py en el directorio ~/project que creaste en los pasos anteriores.

Modifica el código para incluir una declaración if que verifique el valor booleano de una cadena vacía:

## Assign an empty string to a variable
empty_string = ''

## Check if the empty string is truthy or falsy
if empty_string:
    print("The string is truthy")
else:
    print("The string is falsy")

Guarda el archivo.
Ejecuta el script utilizando el comando python:
```
python empty_string.py
```
Deberías ver la siguiente salida:
```
The string is falsy
```
Esto confirma que una cadena vacía se evalúa como False en un contexto booleano.

Ahora, probemos una cadena no vacía en una declaración if:

Modifica el archivo empty_string.py para asignar una cadena no vacía a la variable empty_string:

## Assign a non-empty string to a variable
empty_string = "Hello, LabEx!"

## Check if the non-empty string is truthy or falsy
if empty_string:
    print("The string is truthy")
else:
    print("The string is falsy")

Guarda el archivo.
Ejecuta el script nuevamente:
```
python empty_string.py
```
Deberías ver la siguiente salida:
```
The string is truthy
```
Esto demuestra que una cadena no vacía se evalúa como True en un contexto booleano.

Este comportamiento es útil para comprobar si una cadena se ha asignado un valor o si contiene datos significativos. Puedes utilizar este conocimiento para escribir código Python más robusto y flexible.

Resumen

En este laboratorio (lab), aprendiste sobre las cadenas vacías en Python, que son cadenas que no contienen caracteres y se representan con comillas simples ('') o comillas dobles (""). Creaste una cadena vacía utilizando tanto comillas simples como comillas dobles, la asignaste a una variable y verificaste su tipo como str utilizando la función type().

El laboratorio demostró que tanto las comillas simples como las comillas dobles son intercambiables para crear cadenas vacías en Python. Esta comprensión es crucial, ya que las cadenas vacías se utilizan a menudo para inicializar variables o representar la ausencia de datos.