2.5 Trabajo con Cadenas

1️⃣ Cadenas (clase str)

En Python, una cadena es una secuencia inmutable de caracteres, representada por la clase str.

Se pueden definir con comillas simples, dobles o triples:

texto1 = 'Hola'
texto2 = "Mundo"
texto3 = """Esto es
una cadena
multilínea"""

⚠️ Inmutable significa que no se pueden modificar los caracteres de una cadena ya creada; en su lugar, se generan nuevas cadenas al aplicar operaciones.

---

2️⃣ Acceso a los elementos de una cadena

Dado que una cadena es una secuencia, podemos acceder a sus caracteres mediante índices. Cada carácter tiene asociado un índice que permite acceder a él.

• El índice comienza en 0 (primer carácter).
• Se pueden usar índices negativos para contar desde el final. El índice del último caracter de la cadeba es -1.

palabra = "Python"
print(palabra[0])   # P
print(palabra[2])   # t
print(palabra[-1])  # n

---

3️⃣ Secuencias de escape en cadenas

En Python, las cadenas de texto pueden incluir secuencias de escape, que son combinaciones especiales de caracteres precedidas por una barra invertida (\). Estas secuencias permiten representar caracteres que no se pueden escribir directamente en la cadena (como saltos de línea, tabulaciones o comillas) o que tendrían un significado ambiguo.

Las secuencias de escape más comunes son:

• \n salto de línea
• \t Tabulación (8 espacios)
• \\ Back slash
• \' Comilla simple (')
• \" Comilla doble (")
• \uxxxx Caracter unicode

Ejemplos

# Comillas dentro de una cadena
frase = "Ella dijo: \"Python es genial\""
print(frase)  
# Ella dijo: "Python es genial"

# Saltos de línea y tabulación
texto = "Linea 1\nLinea 2\n\tCon tabulación"
print(texto)
# Linea 1
# Linea 2
#     Con tabulación

# Rutas de Windows
ruta = "C:\\Users\\Alumno\\Documentos"
print(ruta)  
# C:\Users\Alumno\Documentos

# Unicode
print("\u00F1")  # ñ
print("\U0001F602")  # 😂

---

4️⃣ Subcadenas (slicing)

El slicing permite obtener partes de la cadena usando la notación [inicio:fin:paso].

texto = "Programación"
print(texto[1:7])   # 'rogram'
print(texto[:7])    # 'Program'
print(texto[4:])    # 'ramación'
print(texto[::2])   # 'Pormcó' (salta de 2 en 2)
print(texto[0:6:3]) # 'Pg' (salta de 3 en 3)

---

5️⃣ Operaciones con cadenas

Python permite realizar distintas operaciones entre cadenas:

🟩 Concatenación (unir)

a = "Hola"
b = "Mundo"
print(a + " " + b)   # Hola Mundo

🟦 Repetición

print("Ha" * 3)   # HaHaHa

🟨 Comprobar pertenencia

frase = "Aprender Python es divertido"
print("Python" in frase)      # True
print("Java" not in frase)    # True

---

6️⃣ Comparación de cadenas

🟩 Comparación con operadores relacionales

Las cadenas se pueden comparar con los operadores relacionales (==, !=, <, >, <=, >=). La comparación se hace carácter por carácter siguiendo el orden Unicode (lo que implica que las mayúsculas y minúsculas tienen distinto valor).

print("hola" == "hola")   # True
print("Hola" == "hola")   # False (mayúsculas ≠ minúsculas)
print("abc" < "abd")      # True (compara letra por letra)
print("zorro" > "avion")  # True ("z" > "a" en Unicode)

en este ejemplo

Esto significa que "Hola" y "hola" no son iguales, aunque visualmente lo parezcan, porque el código Unicode de "H" (72) es distinto del de "h" (104).

🟦 Operadores de pertenencia en cadenas

Los operadores in y not in permiten comprobar si una subcadena se encuentra dentro de otra cadena.

Operador	Descripción	Ejemplo	Resultado
in	Devuelve True si la subcadena está presente.	"py" in "python"	True
not in	Devuelve True si la subcadena no está presente.	"java" not in "python"	True

Ejemplos

texto = "Python es genial"

print("Python" in texto)        # True (está al inicio)
print("genial" in texto)        # True (está al final)
print("Java" not in texto)      # True (no aparece en la cadena)
print("PYTHON" in texto)        # False (sensible a mayúsculas)

en este ejemplo

La comparación de pertenencia en cadenas también es sensible a mayúsculas y minúsculas, al igual que los operadores relacionales.

---

7️⃣ Funciones de cadenas

Las cadenas de texto en Python (str) disponen de una gran variedad de métodos integrados que permiten transformarlas, analizarlas y darles formato. Estos métodos se aplican directamente sobre la cadena y devuelven un nuevo resultado, ya que las cadenas son inmutables (no se modifican en el lugar).

A continuación se describen algunos de los métodos más utilizados con ejemplos.

🟩 Cambio de formato y mayúsculas/minúsculas

• capitalize(): convierte el primer carácter en mayúscula y el resto en minúsculas.
• title(): convierte la primera letra de cada palabra en mayúscula.
• upper(): convierte todos los caracteres a mayúsculas.
• lower(): convierte todos los caracteres a minúsculas.
• swapcase(): invierte mayúsculas ↔ minúsculas.

Ejemplo

texto = "aprender python es divertido"
print(texto.capitalize())  # Aprender python es divertido
print(texto.title())       # Aprender Python Es Divertido
print(texto.upper())       # APRENDER PYTHON ES DIVERTIDO
print(texto.lower())       # aprender python es divertido
print("Hola Mundo".swapcase())  # hOLA mUNDO

🟦 Búsqueda y conteo

• count(sub[, start, end]): cuenta cuántas veces aparece una subcadena.
• find(sub): devuelve el índice de la primera aparición o -1.
• rfind(sub): devuelve el índice de la última aparición o -1.
• index(sub): como find, pero lanza ValueError si no encuentra.
• rindex(sub): como rfind, pero lanza ValueError.
• startswith(prefijo): comprueba si la cadena empieza por un valor.
• endswith(sufijo): comprueba si la cadena termina en un valor.

Ejemplo

texto = "aprender python es divertido"
print(texto.count("y"))        # 1
print(texto.find("es"))        # 16
print(texto.rfind("er"))       # 22
print(texto.startswith("ap"))  # True
print(texto.endswith("do"))    # True

🟨 Eliminación y reemplazo

• strip([chars]): elimina caracteres al inicio y al final.
• replace(old, new): reemplaza subcadenas.
• split([sep]): divide en lista según un separador.
• join(iterable): une una lista de cadenas en una sola, con un separador.

Ejemplo

txt = "  hola python  "
print(txt.strip())  # "hola python"

print("python".replace("py", "co"))  # "cothon"

print("uno,dos,tres".split(","))     # ['uno', 'dos', 'tres']

print(", ".join(["manzana", "pera"]))  # "manzana, pera"

🟧 Comprobaciones de contenido

• isalnum(): True si son letras o números.
• isalpha(): True si solo son letras.
• isdecimal(): True si son solo dígitos decimales (0–9).
• isdigit(): True si son números (incluye algunos unicode como ²).
• isnumeric(): True si son números o relacionados (incluye fracciones).
• isidentifier(): True si es un identificador válido en Python.
• islower(): True si todos los caracteres alfabéticos están en minúscula.
• isupper(): True si todos los caracteres alfabéticos están en mayúscula.

Ejemplo

print("Python3".isalnum())     # True
print("Python".isalpha())      # True
print("123".isdecimal())       # True
print("²".isdigit())           # True
print("½".isnumeric())         # True
print("variable".isidentifier())  # True
print("python".islower())      # True
print("PYTHON".isupper())      # True

---

8️⃣ Formato de cadenas y números en Python

En Python existen varias formas de insertar valores dentro de cadenas de texto. Esto es muy útil cuando queremos mostrar resultados calculados, mensajes personalizados o informes con valores numéricos.

🟩 Concatenación simple

La forma más básica es concatenar cadenas con el operador +.

nombre = "Ana"
edad = 20
print("Hola " + nombre + ", tienes " + str(edad) + " años")

en este ejemplo

Es necesario convertir a cadena con str() cuando el valor no lo es.

🟦 Método .format()

El método .format() permite insertar valores en posiciones marcadas por llaves {}.

nombre = "Ana"
edad = 20
print("Me llamo {} y tengo {} años".format(nombre, edad))

También se pueden reordenar o repetir los valores:

print("Edad: {1}, Nombre: {0}".format(nombre, edad))  # Edad: 20, Nombre: Ana

🟨 F-strings (desde Python 3.6)

La forma más recomendada es usar f-strings, que permiten incrustar variables y expresiones directamente entre llaves {}.

nombre = "Ana"
edad = 20
print(f"Me llamo {nombre} y tengo {edad} años")
print(f"El doble de 5 es {5*2}")  # El doble de 5 es 10

---

9️⃣ Formato numérico con f-strings y .format()

Python ofrece gran flexibilidad para mostrar números con el formato deseado:

🟩 Decimales con precisión fija

PI = 3.14159265
print(f"Pi con 2 decimales: {PI:.2f}")        # 3.14
print("Pi con 4 decimales: {:.4f}".format(pi)) # 3.1416

🟦 Parte entera con ceros a la izquierda

numero = 42
print(f"Número con ceros: {numero:05d}")  # 00042

🟨 Alineación de texto y números

valor = 123
print(f"Alineado a la derecha: {valor:>10}")  # '       123'
print(f"Alineado a la izquierda: {valor:<10}") # '123       '
print(f"Centrado: {valor:^10}")                # '   123    '

🟧 Separadores de miles

grande = 1234567
print(f"Con separador de miles: {grande:,}")   # 1,234,567
print(f"Formato europeo: {grande:_}")          # 1_234_567

🟥 Porcentajes

tasa = 0.2567
print(f"Porcentaje: {tasa:.2%}")   # 25.67%

📊 Tabla resumen de especificadores de formato

Especificador	Significado	Ejemplo	Resultado
:.2f	Número con 2 decimales	f"{3.1415:.2f}"	3.14
:05d	Entero con 5 dígitos, rellenado con ceros	f"{42:05d}"	00042
:>10	Alineado a la derecha en 10 espacios	f"{123:>10}"	123
:<10	Alineado a la izquierda en 10 espacios	f"{123:<10}"	123
:^10	Centrado en 10 espacios	f"{123:^10}"	123
:,	Separador de miles con coma	f"{1234567:,}"	1,234,567
:.2%	Porcentaje con 2 decimales	f"{0.2567:.2%}"	25.67%

---