Trabajar con Cadenas (*Strings*) en Python

PythonBeginner
Practicar Ahora

Introducción

En este laboratorio, obtendrá experiencia práctica trabajando con cadenas (strings) en Python, un tipo de dato fundamental. Comenzará comprendiendo los conceptos básicos de las cadenas, incluyendo su creación, inmutabilidad y el acceso a caracteres individuales utilizando indexación tanto positiva como negativa.

Basándose en esta base, aprenderá a extraer subcadenas mediante el slicing (rebanado), a utilizar varios operadores de cadenas y caracteres de escape para manipulación y formato especial, y explorará diferentes métodos para formatear cadenas. Finalmente, profundizará en los métodos comunes de cadenas para realizar operaciones como buscar, reemplazar y modificar el contenido de las cadenas.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 97%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Comprender los Conceptos Básicos de Cadenas e Indexación

En este paso, aprenderá los conceptos fundamentales de las cadenas (strings) en Python, incluyendo cómo crearlas y acceder a caracteres individuales mediante la indexación. Las cadenas son secuencias de caracteres y son uno de los tipos de datos más comunes. Puede crear cadenas usando comillas simples ('...') o comillas dobles ("...").

Una característica clave de las cadenas de Python es que son inmutables, lo que significa que su contenido no se puede cambiar una vez creadas. Cualquier operación que parezca modificar una cadena en realidad crea una nueva.

Exploremos esto. En el WebIDE, abra el archivo string_basics.py desde el directorio ~/project en el explorador de archivos de la izquierda. Agregue el siguiente código:

## string_basics.py

## Las cadenas son inmutables. Asignar una nueva cadena a una variable
## crea un nuevo objeto de cadena con una nueva dirección de memoria.
a = "hello"
print(f"Value: {a}, ID: {id(a)}")

a = "hi"
print(f"Value: {a}, ID: {id(a)}")

Para ejecutar el script, abra una terminal en el WebIDE (Terminal -> New Terminal) y ejecute el siguiente comando:

python ~/project/string_basics.py

Verá una salida similar a esta, donde los valores de ID son diferentes, lo que confirma que se creó un nuevo objeto de cadena.

Value: hello, ID: <placeholder>
Value: hi, ID: <placeholder>

Ahora, exploremos la indexación de cadenas. Puede acceder a caracteres individuales utilizando su índice (posición). En Python, la indexación comienza en 0 para el primer carácter.

Modifique el archivo string_basics.py para incluir la indexación positiva:

## string_basics.py
a = "Hello"

## Indexación positiva (desde el principio)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])

## Acceder a un índice que no existe provocará un IndexError.
## print(a[5])

Guarde el archivo y ejecútelo de nuevo:

python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o

Python también admite la indexación negativa, que accede a los caracteres desde el final de la cadena. El último carácter está en el índice -1, el penúltimo en -2, y así sucesivamente.

Agregue ejemplos de indexación negativa a string_basics.py:

## string_basics.py
a = "Hello"

## Indexación positiva (desde el principio)
print("Positive Indexing:")
print(a[0])
print(a[1])
print(a[2])
print(a[3])
print(a[4])

## Indexación negativa (desde el final)
print("\nNegative Indexing:")
print(a[-5])
print(a[-4])
print(a[-3])
print(a[-2])
print(a[-1])

## Debido a que las cadenas son inmutables, no puede cambiar un carácter.
## La siguiente línea causaría un TypeError: 'str' object does not support item assignment
## a[0] = "J"

Guarde el archivo y ejecútelo por última vez para este paso:

python ~/project/string_basics.py
Positive Indexing:
H
e
l
l
o

Negative Indexing:
H
e
l
l
o

Rebanar Cadenas (Slicing)

En este paso, aprenderá a extraer subcadenas de una cadena utilizando el slicing (rebanado). Mientras que la indexación obtiene un solo carácter, el slicing obtiene una secuencia de caracteres.

La sintaxis básica para el slicing es string[start:end]. Esto extrae la parte de la cadena desde el índice start hasta, pero sin incluir, el índice end.

Abra el archivo string_slicing.py desde el directorio ~/project. Agregue el siguiente código para demostrar el slicing básico:

## string_slicing.py
a = "Hello World"

## Rebanar desde el índice 0 hasta (pero sin incluir) el índice 5
print(a[0:5])

## Rebanar desde el índice 6 hasta el final de la cadena
print(a[6:])

## Rebanar desde el principio hasta (pero sin incluir) el índice 5
print(a[:5])

## Uso de índices negativos para el rebanado
print(a[-5:-2])

## Obtener una copia de la cadena completa
print(a[:])

Guarde el archivo y ejecútelo desde la terminal:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World

El slicing también puede tomar un tercer parámetro, step (paso), con la sintaxis string[start:end:step]. El valor de step determina el intervalo entre caracteres en la porción seleccionada.

Modifique string_slicing.py para incluir ejemplos con un paso:

## string_slicing.py
a = "Hello World"

## ... (código anterior) ...

b = "0123456789"

## Obtener cada segundo carácter desde el principio hasta el final
print(b[::2])

## Obtener caracteres desde el índice 1 hasta el 7, con un paso de 3
print(b[1:7:3])

## Un paso negativo invierte la dirección. Esto invierte toda la cadena.
print(b[::-1])

## Invertir desde el índice 7 hasta (pero sin incluir) el índice 2
print(b[7:2:-1])

Guarde el archivo y ejecútelo de nuevo:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543

El slicing es tolerante y maneja automáticamente los índices que están fuera de los límites, lo que previene errores.

Agregue estas líneas finales a string_slicing.py para ver este comportamiento:

## string_slicing.py
a = "Hello World"

## ... (código anterior) ...

b = "0123456789"

## ... (código anterior) ...

## Slicing con índices fuera de límites
c = "Python"
## El índice final es mayor que la longitud de la cadena, pero funciona correctamente.
print(c[2:100])

## El índice inicial está antes del principio, pero funciona correctamente.
print(c[-100:4])

Guarde y ejecute el script:

python ~/project/string_slicing.py
Hello
World
Hello
Wor
Hello World
02468
14
9876543210
76543
thon
Pyth

Utilizar Operadores de Cadenas y Caracteres de Escape

En este paso, aprenderá sobre los operadores comunes utilizados con las cadenas (strings) y cómo usar los caracteres de escape para representar caracteres especiales.

Python proporciona varios operadores para la manipulación de cadenas. Los operadores in y not in verifican la existencia de subcadenas, + concatena cadenas, y * repite una cadena.

Abra el archivo string_operators.py en el WebIDE y agregue el siguiente código:

## string_operators.py

## El operador 'in' comprueba si una subcadena existe dentro de una cadena
print('e' in 'Hello')
print('x' in 'Hello')

## El operador 'not in' es lo opuesto a 'in'
print('e' not in 'Hello')
print('x' not in 'Hello')

## La concatenación (+) une dos cadenas
print('Hello' + ' ' + 'World')

## La repetición (*) repite una cadena un número determinado de veces
print('=' * 20)
print('Go! ' * 3)

Guarde el archivo y ejecútelo:

python ~/project/string_operators.py
True
False
False
True
Hello World
====================
Go! Go! Go!

A continuación, veamos los caracteres de escape. Estas son secuencias especiales que comienzan con una barra invertida (\) y representan caracteres no imprimibles o especiales.

Abra el archivo escape_characters.py y agregue el siguiente código:

## escape_characters.py

## Use \' o \" para incluir comillas dentro de una cadena
print('It\'s a beautiful day.')
print("He said, \"Python is fun!\"")

## \n crea una nueva línea
print("First line\nSecond line")

## \t crea una tabulación horizontal
print("Column1\tColumn2\tColumn3")

## \\ representa una barra invertida literal
print("This is a backslash: \\")

## Una cadena literal (*raw string*), prefijada con 'r', trata las barras invertidas como caracteres literales.
## Esto es muy útil para rutas de archivos y expresiones regulares (*regular expressions*).
print("A normal string: C:\\Users\\new_folder")
print(r"A raw string: C:\Users\new_folder")

Guarde el archivo y ejecútelo:

python ~/project/escape_characters.py
It's a beautiful day.
He said, "Python is fun!"
First line
Second line
Column1 Column2 Column3
This is a backslash: \
A normal string: C:\Users\new_folder
A raw string: C:\Users\new_folder

Formatear Cadenas (Format Strings)

En este paso, aprenderá formas modernas y efectivas de formatear cadenas (strings) en Python. Esto es crucial para crear salidas dinámicas y legibles al incrustar variables y expresiones dentro de las cadenas.

Aunque puede usar el operador + para concatenar cadenas, se vuelve torpe al mezclar cadenas con tipos que no son cadenas, como números, ya que debe convertirlos manualmente usando str().

Python ofrece mejores soluciones. El método más común y recomendado es usar f-strings (literales de cadena formateados).

Formato con f-string

Las f-strings, introducidas en Python 3.6, proporcionan una forma concisa y legible de incrustar expresiones dentro de las cadenas. Simplemente antepone a la cadena f o F y escribe expresiones dentro de llaves {}.

Abra el archivo string_formatting.py y agregue el siguiente código:

## string_formatting.py

name = "Alice"
age = 30

## Usando una f-string para incrustar variables
greeting = f"Hello, my name is {name} and I am {age} years old."
print(greeting)

## También puede incrustar expresiones directamente
print(f"In 5 years, I will be {age + 5} years old.")

Guarde y ejecute el script:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.

Especificadores de Formato (Format Specifiers)

Las f-strings también le permiten controlar el formato de los valores incrustados utilizando especificadores de formato, que siguen a dos puntos (:) dentro de las llaves.

Agregue los siguientes ejemplos a string_formatting.py:

## string_formatting.py

## ... (código anterior) ...

pi = 3.14159265

## Formatear un flotante (*float*) a 2 decimales
print(f"The value of pi is approximately {pi:.2f}")

## Rellenar un número con ceros a la izquierda hasta un ancho de 8
order_id = 45
print(f"Order ID: {order_id:08}")

## Alinear texto dentro de un espacio dado (ancho de 10)
## < (izquierda), ^ (centro), > (derecha)
text = "Python"
print(f"'{text:<10}'")
print(f"'{text:^10}'")
print(f"'{text:>10}'")

## Añadir coma como separador de miles
large_number = 1234567890
print(f"A large number: {large_number:,}")

Guarde y ejecute el script nuevamente:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python    '
'  Python  '
'    Python'
A large number: 1,234,567,890

El Método str.format()

Antes de las f-strings, el método str.format() era la forma preferida de formatear cadenas. Funciona colocando llaves de marcador de posición {} en la cadena y luego pasando valores al método format().

Agregue este ejemplo al final de string_formatting.py:

## string_formatting.py

## ... (código anterior) ...

## Usando el método str.format()
item = "moon"
cost = 99.95
statement = "The {} costs {:.2f} dollars.".format(item, cost)
print(statement)

Guarde y ejecute el archivo para ver la salida:

python ~/project/string_formatting.py
Hello, my name is Alice and I am 30 years old.
In 5 years, I will be 35 years old.
The value of pi is approximately 3.14
Order ID: 00000045
'Python    '
'  Python  '
'    Python'
A large number: 1,234,567,890
The moon costs 99.95 dollars.

Aunque str.format() sigue siendo útil, las f-strings son generalmente más legibles y rápidas.

Explorar Métodos Comunes de Cadenas (Common String Methods)

En este paso final, explorará algunos de los métodos integrados (built-in methods) más comunes y útiles para los objetos de cadena (string objects). Estos métodos realizan diversas operaciones como cambiar el caso, buscar y reemplazar texto, y dividir cadenas en listas.

Recuerde que las cadenas son inmutables, por lo que estos métodos siempre devuelven una cadena nueva y no modifican la original.

Abra el archivo string_methods.py y agregue el siguiente código para ver estos métodos en acción:

## string_methods.py

## Métodos de conversión de caso
s1 = "Hello, World!"
print(f"Original: '{s1}'")
print(f"En mayúsculas: '{s1.upper()}'")
print(f"En minúsculas: '{s1.lower()}'")
print(f"En formato de título: '{s1.title()}'")
print("-" * 20)

## Búsqueda y reemplazo
s2 = "The quick brown fox jumps over the lazy dog."
print(f"Original: '{s2}'")
## Comprobar si una cadena comienza o termina con una subcadena
print(f"Comienza con 'The': {s2.startswith('The')}")
print(f"Termina con 'dog.': {s2.endswith('dog.')}")
## Encontrar el índice de una subcadena (-1 si no se encuentra)
print(f"Índice de 'fox': {s2.find('fox')}")
## Reemplazar una subcadena por otra
s3 = s2.replace("brown", "red")
print(f"Después de reemplazar: '{s3}'")
print("-" * 20)

## Eliminar espacios en blanco (*stripping whitespace*)
s4 = "    some whitespace    "
print(f"Original: '{s4}'")
## strip() elimina de ambos extremos, lstrip() de la izquierda, rstrip() de la derecha
print(f"Limpiado: '{s4.strip()}'")
print("-" * 20)

## Dividir y unir (*Splitting and joining*)
s5 = "one,two,three,four"
print(f"Original: '{s5}'")
## Dividir la cadena en una lista de subcadenas basándose en un delimitador
parts = s5.split(',')
print(f"Lista dividida: {parts}")
## Unir los elementos de una lista en una sola cadena con un separador
s6 = " ".join(parts)
print(f"Cadena unida: '{s6}'")

Guarde el archivo y ejecútelo desde la terminal:

python ~/project/string_methods.py

Su salida debería verse así:

Original: 'Hello, World!'
Upper case: 'HELLO, WORLD!'
Lower case: 'hello, world!'
Title case: 'Hello, World!'
--------------------
Original: 'The quick brown fox jumps over the lazy dog.'
Starts with 'The': True
Ends with 'dog.': True
Index of 'fox': 16
After replace: 'The quick red fox jumps over the lazy dog.'
--------------------
Original: '    some whitespace    '
Stripped: 'some whitespace'
--------------------
Original: 'one,two,three,four'
Split list: ['one', 'two', 'three', 'four']
Joined string: 'one two three four'

Estos son solo algunos de los muchos métodos de cadena disponibles en Python. Proporcionan herramientas potentes para procesar y manipular datos de texto.

Resumen

En este laboratorio, ha aprendido los conceptos fundamentales para trabajar con cadenas (strings) en Python. Comenzó con los conceptos básicos, entendiendo cómo crear cadenas y reconociendo su naturaleza inmutable. Practicó el acceso a caracteres individuales tanto con indexación positiva como negativa y la extracción de subcadenas mediante slicing (rebanado) con parámetros de inicio (start), fin (end) y paso (step).

Luego exploró los operadores de cadenas para concatenación (+) y repetición (*), y aprendió a usar caracteres de escape para incluir caracteres especiales en sus cadenas. Dominó las técnicas modernas de formato de cadenas, centrándose en el poder y la legibilidad de las f-strings y sus especificadores de formato (format specifiers), al tiempo que vio el método str.format(). Finalmente, practicó el uso de métodos comunes de cadenas como upper(), lower(), replace(), strip(), split() y join() para realizar tareas esenciales de manipulación de texto.