Cadenas

El texto aparece en casi todos los programas que escribes. Nombres, mensajes, puntajes, etiquetas. En Python, cualquier fragmento de texto se llama cadena (string): cualquier valor que envuelvas entre comillas. Simples o dobles, ambas funcionan igual.

python

greeting = "Hola, mundo"
username = 'sofia'

La única vez que importa la elección de las comillas es cuando tu texto contiene comillas. Usa el estilo opuesto para no tener que escaparlas:

python

note    = "It's a great day"      # apóstrofo dentro, usa comillas dobles
message = 'She said "hello"'      # comillas dobles dentro, usa comillas simples
escaped = "She said \"hello\""    # o escapa con una barra invertida

Inmutabilidad

Las cadenas son inmutables: una vez que creas una, no puedes modificarla. Piensa en una cadena como algo permanentemente fijo desde el momento en que se crea. Cualquier operación que parezca modificar una cadena en realidad produce una completamente nueva. La original permanece exactamente como estaba.

python

name = "sofia"
name = name.upper()   # "SOFIA" es una nueva cadena; "sofia" no cambia

La consecuencia directa: no puedes cambiar un carácter en una posición específica. Python generará un error si lo intentas.

python

name = "sofia"
name[0] = "S"   # TypeError: 'str' object does not support item assignment

Para obtener una cadena modificada, construye una nueva usando segmentación o un método. Ambos se cubren a continuación.

Indexación y segmentación

Cada carácter de una cadena tiene una posición numerada, comenzando desde cero. Puedes leer caracteres individuales colocando ese número de posición entre corchetes. Los números negativos cuentan hacia atrás desde el final.

python

word = "Python"
#       012345

print(word[0])    # "P"
print(word[2])    # "t"
print(word[5])    # "n"
print(word[-1])   # "n"  (último carácter)
print(word[-2])   # "o"  (penúltimo)

-1 siempre es el último carácter, -2 el penúltimo, y así sucesivamente. Son útiles cuando quieres el final de una cadena sin conocer su longitud exacta.

La segmentación extrae un fragmento. [start:stop] incluye start y excluye stop:

python

word = "Python"

print(word[0:2])   # "Py"     (posiciones 0 y 1)
print(word[2:])    # "thon"   (posición 2 al final)
print(word[:3])    # "Pyt"    (inicio a la posición 2)
print(word[:])     # "Python" (una copia de la cadena completa)
print(word[::2])   # "Pto"    (cada segundo carácter)
print(word[::-1])  # "nohtyP" (invertida)

Tres patrones que usarás más: word[:n] para los primeros n caracteres, word[n:] para todo desde la posición n en adelante, word[-n:] para los últimos n caracteres. word[::-1] invierte una cadena. Se ve extraño la primera vez, pero es idiomático en Python y lo verás a menudo.

Métodos esenciales de cadenas

Las cadenas vienen con un conjunto de métodos integrados: operaciones que llamas directamente sobre cualquier valor de cadena. Escribes la cadena (o la variable que la contiene), luego un punto, luego el nombre del método. Cada método devuelve una nueva cadena. La original nunca se modifica.

Capitalización

python

text = "Hello, World"

text.lower()       # "hello, world"
text.upper()       # "HELLO, WORLD"
text.title()       # "Hello, World"  (cada palabra capitalizada)
text.capitalize()  # "Hello, world"  (solo la primera palabra)

lower() y upper() son los dos que más usarás. lower() es particularmente útil al comparar texto: "Sofia" y "sofia" se convierten en lo mismo una vez que llamas a .lower() en ambos lados.

Espacios en blanco

python

text = "  hello  "

text.strip()    # "hello"    (ambos lados)
text.lstrip()   # "hello  "  (solo izquierda)
text.rstrip()   # "  hello"  (solo derecha)

strip() elimina los espacios de ambos extremos de una cadena. Lo usarás casi siempre que manejes entradas de usuario o texto de un archivo, porque los espacios extraviados causan fallas silenciosas: "sofia" != "sofia ".

Búsqueda

python

text = "Hello, world"

text.find("world")         # 7
text.find("Python")        # -1  (no encontrado)
text.count("l")            # 3
text.startswith("Hello")   # True
text.endswith("world")     # True

find() devuelve la posición donde comienza un fragmento de texto dentro de tu cadena. Si no está, devuelve -1. Usa startswith() y endswith() cuando solo te importa si la cadena comienza o termina con algo específico.

Reemplazo

python

text = "Hello, world"

text.replace("world", "Python")   # "Hello, Python"
text.replace("l", "L")            # "HeLLo, worLd"  (todas las ocurrencias)
text.replace("l", "L", 1)         # "HeLlo, world"  (solo la primera)

replace() cambia cada ocurrencia de un fragmento de texto por otro y te devuelve una nueva cadena. La original no se modifica. Pasa un tercer argumento si solo quieres reemplazar la primera ocurrencia.

División y unión

split() corta una cadena en piezas en un separador y las devuelve como una lista. Le dices con qué cortar:

python

csv_row = "Sofía,28,Ciudad de México"
parts = csv_row.split(",")     # ["Sofía", "28", "Ciudad de México"]

"  hello   world  ".split()   # ["hello", "world"]

¿Qué es una lista?

Una lista es una colección ordenada de valores. ["Sofía", "28", "Ciudad de México"] arriba es una. Las listas tienen su propio capítulo; por ahora, trátalas como una secuencia de elementos que split() produce y join() consume.

join() hace lo contrario: combina una lista de cadenas en una sola. La cadena antes de .join() se coloca entre cada elemento:

python

words = ["Hola", "mundo"]

" ".join(words)    # "Hola mundo"
", ".join(words)   # "Hola, mundo"
"".join(words)     # "Holamundo"

El patrón que debes recordar: separador.join(lista_de_cadenas). El separador va a la izquierda, la lista a la derecha. " ".join(words) pone un espacio entre cada palabra. "".join(words) las pega sin nada entre ellas.

f-strings

Los f-strings incrustan valores directamente dentro del texto. Pon f antes de la comilla de apertura, luego envuelve cualquier variable o expresión entre llaves. Python lo completa cuando se ejecuta el código. También puedes agregar dos puntos después del valor para controlar cómo se muestra.

python

name  = "Sofía"
score = 94.5

print(f"¡Hola, {name}!")           # "¡Hola, Sofía!"
print(f"Puntaje: {score:.1f}%")    # "Puntaje: 94.5%"
print(f"2 + 2 = {2 + 2}")          # "2 + 2 = 4"
print(f"Nombre: {name.upper()}")   # "Nombre: SOFÍA"

La especificación de formato después de : controla cómo se muestra el valor:

Spec	Significado	Ejemplo
`.2f`	2 lugares decimales	`f"{3.14159:.2f}"` → `"3.14"`
`.0%`	porcentaje, sin decimales	`f"{0.94:.0%}"` → `"94%"`
`,`	separador de miles	`f"{1000000:,}"` → `"1,000,000"`
`>10`	alinear a la derecha en 10 caracteres	`f"{'hi':>10}"` → `" hi"`

Usarás .2f más: cada vez que muestres un decimal y quieras un número ordenado en lugar de una larga serie de dígitos. Todo lo demás en la tabla está ahí cuando lo necesites. Puedes poner cualquier variable, aritmética o llamada a método dentro de {}.

Cadenas multilínea

Para escribir una cadena que abarque más de una línea, usa comillas triples: tres " al inicio y tres al final. Python preserva todos los saltos de línea y el espaciado exactamente como los escribiste.

python

message = """
Estimada Sofía,

Gracias por su pedido.

Saludos cordiales,
El Equipo
"""

Secuencias de escape

Algunos caracteres son difíciles de escribir directamente dentro de una cadena. Python usa secuencias de escape: una barra invertida seguida de una letra que representa algo. Las dos que usarás constantemente son \n para una nueva línea y \t para una tabulación.

Secuencia	Carácter
`\n`	Nueva línea
`\t`	Tabulación
`\\`	Barra invertida literal
`\"`	Comilla doble
`\'`	Comilla simple

python

print("Línea uno\nLínea dos")      # dos líneas de salida
print("Nombre:\tSofía")            # Nombre:   Sofía
path = r"C:\Users\Sofia\Documents" # cadena en bruto, sin procesamiento de escape

Verificar el contenido de cadenas

Python tiene métodos que responden preguntas de sí/no sobre lo que contiene una cadena. Devuelven True o False. El más útil al principio: isdigit() te permite verificar si una cadena es toda números antes de convertirla, para que puedas evitar un fallo en entradas inesperadas.

python

"42".isdigit()       # True
"hello".isalpha()    # True
"hello42".isalnum()  # True
"   ".isspace()      # True
"Hello".islower()    # False
"HELLO".isupper()    # True

En la práctica

Elimina los espacios en blanco, normaliza la capitalización, luego extrae lo que necesitas. Esta secuencia maneja casi cualquier texto proporcionado por el usuario:

python

raw_input = "  [email protected]  "
email     = raw_input.strip().lower()   # "[email protected]"

at_pos   = email.find("@")
username = email[:at_pos]
domain   = email[at_pos + 1:]

print(f"Usuario: {username}")   # "sofia"
print(f"Dominio: {domain}")     # "example.com"

Referencia de métodos

Método	Qué hace
`.lower()` / `.upper()`	Convierte todo a minúsculas / todo a mayúsculas
`.title()` / `.capitalize()`	Capitaliza cada palabra / solo la primera
`.strip()` / `.lstrip()` / `.rstrip()`	Elimina espacios en blanco circundantes
`.find(sub)`	Índice de la primera coincidencia, o `-1`
`.count(sub)`	Cuántas veces aparece `sub`
`.startswith(s)` / `.endswith(s)`	Verificación de prefijo / sufijo
`.replace(old, new)`	Reemplaza ocurrencias
`.split(sep)`	Divide en una lista
`sep.join(iterable)`	Une elementos en una cadena
`.isdigit()` / `.isalpha()` / `.isalnum()`	Verificaciones de tipo de carácter

Cadenas ​

Inmutabilidad ​

Indexación y segmentación ​

Métodos esenciales de cadenas ​

Capitalización ​

Espacios en blanco ​

Búsqueda ​

Reemplazo ​

División y unión ​

f-strings ​

Cadenas multilínea ​

Secuencias de escape ​

Verificar el contenido de cadenas ​

En la práctica ​

Referencia de métodos ​

Cadenas

Inmutabilidad

Indexación y segmentación

Métodos esenciales de cadenas

Capitalización

Espacios en blanco

Búsqueda

Reemplazo

División y unión

f-strings

Cadenas multilínea

Secuencias de escape

Verificar el contenido de cadenas

En la práctica

Referencia de métodos