Cadenas de texto

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

python

greeting = "Hello, world"
username = 'carlos'

La única vez que importa la elección de 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 de texto son inmutables: una vez que creas una, no puedes cambiarla. Piensa en una cadena como permanentemente fija en el momento en que se crea. Cualquier operación que parezca modificar una cadena en realidad produce una completamente nueva. La original sigue exactamente como estaba.

python

name = "alice"
name = name.upper()   # "ALICE" es una cadena nueva; "alice" no cambia

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

python

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

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

JunoInmutabilidad Una cadena nunca cambia una vez que existe. Cualquier cosa que parezca editarla te devuelve una cadena nueva en su lugar, así que asigna el resultado o se desvanece. La que me atrapó al principio: name[0] = "A" no funciona, lanza un TypeError.

Indexación y corte

Cada carácter en una cadena tiene una posición numerada, comenzando en cero. Puedes leer caracteres individuales poniendo 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 es siempre el último carácter, -2 el penúltimo, y así sucesivamente. Son útiles cuando quieres el final de una cadena sin conocer su largo exacto.

El corte extrae un trozo. [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 posición 2)
print(word[:])     # "Python" (copia de toda la cadena)
print(word[::2])   # "Pto"    (cada segundo carácter)
print(word[::-1])  # "nohtyP" (invertida)

Tres patrones a alcanzar más frecuentemente: 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 raro la primera vez, pero es Python idiomático y lo verás a menudo.

JunoIndexación y corte Las posiciones empiezan en cero, así que word[0] es el primer carácter y word[-1] es el último. Un corte agarra un rango: word[start:stop] mantiene start y se detiene justo antes de stop. word[::-1] invierte la cadena, que se ve extraño la primera vez y luego lo usas por siempre.

Métodos esenciales de cadenas

Las cadenas vienen con un conjunto de métodos integrados: operaciones que llamas directamente en 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 cadena nueva. La original nunca cambia.

Mayúsculas y minúsculas

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 usarás más. lower() es particularmente útil cuando comparas texto: "Alice" y "alice" se convierten en la misma cosa una vez que llamas .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 espacios de ambos extremos de una cadena. La usarás casi cada vez que manejes entrada del usuario o texto de un archivo, porque los espacios extraviados causan fallos silenciosos: "carlos" != "carlos ".

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 un trozo de texto comienza dentro de tu cadena. Si no está ahí, 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() intercambia cada ocurrencia de un trozo de texto por otro y te devuelve una cadena nueva. La original no cambia. 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 qué cortar:

python

csv_row = "Carlos,28,México"
parts = csv_row.split(",")     # ["Carlos", "28", "México"]

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

split() devuelve una lista, una secuencia ordenada de valores. Tienen su propio capítulo Listas; por ahora trata como la secuencia de partes que split() produce y join() consume.

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

python

words = ["Hello", "world"]

" ".join(words)    # "Hello world"
", ".join(words)   # "Hello, world"
"".join(words)     # "Helloworld"

El patrón a recordar: separator.join(list_of_strings). El separador va a la izquierda, la lista a la derecha. " ".join(words) pone un espacio entre cada palabra. "".join(words) las pega con nada entre.

JunoMétodos esenciales de cadenas Cada uno devuelve una cadena nueva, así que asigna el resultado o se va. El puñado al que alcanzarás diariamente: .lower() y .upper() para mayúsculas/minúsculas, .strip() para recortar espacios extraviados, .find() para ubicar texto (devuelve -1 cuando no está), .replace() para intercambiar texto, y .split() con sep.join() para desmontar una cadena y volver a armarla.

f-strings

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

python

name = "Carlos"
score = 94.5

print(f"Hello, {name}!")           # "Hello, Carlos!"
print(f"Score: {score:.1f}%")      # "Score: 94.5%"
print(f"2 + 2 = {2 + 2}")          # "2 + 2 = 4"
print(f"Name: {name.upper()}")     # "Name: CARLOS"

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

Spec	Significado	Ejemplo
`.2f`	2 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`	alineado a la derecha en 10 caracteres	`f"{'hola':>10}"` → `" hola"`

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

Junof-strings Pon f antes de la comilla de apertura, luego envuelve cualquier variable, suma, o llamada a método en {} y Python suelta el resultado cuando la línea se ejecuta. Un dos puntos dentro de las llaves controla el aspecto: :.2f para dos decimales es el que usarás. Mucho más limpio que pegar texto con +.

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 espacios exactamente como los escribiste.

python

message = """
Dear Carlos,

Thank you for your order.

Best regards,
The Team
"""

JunoCadenas multilínea Tres comillas al final de cada final permiten que una cadena corra a través de varias líneas, y Python mantiene cada salto de línea y espacio exactamente como los escribiste. Alcanza por ellas cada vez que tengas un bloque de texto, como un mensaje o una plantilla, que no quepa cómodamente en una línea.

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`	Salto de línea
`\t`	Tabulación
`\\`	Barra invertida literal
`\"`	Comilla doble
`\'`	Comilla simple

python

print("Line one\nLine two")        # dos líneas de salida
print("Name:\tCarlos")             # Name:   Carlos
path = r"C:\Users\Carlos\Documents" # cadena cruda, sin procesamiento de escape

JunoSecuencias de escape Una barra invertida dentro de una cadena significa "lee el siguiente carácter especialmente": \n comienza una línea nueva, \t inserta una tabulación, \\ es una barra invertida real. Esas dos, \n y \t, son las que realmente escribirás. Pon una r antes de la comilla y las barras invertidas vuelven a ser planas, útil para rutas de Windows.

Verificar contenidos de cadenas

Python tiene métodos que responden preguntas sí/no sobre qué contiene una cadena. Devuelven True o False. La más útil al principio: isdigit() te deja verificar si una cadena es solo números antes de convertirla, así puedes evitar un fallo en entrada inesperada.

python

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

JunoVerificar contenidos de cadenas Los métodos is* responden preguntas sí-o-no y devuelven True solo cuando cada carácter se ajusta. El que usarás primero: llama isdigit() antes de int() para asegurate de que el texto realmente es un número, así que entrada rara no te cuelga.

En la práctica

Elimina espacio en blanco, normaliza mayúsculas/minúsculas, luego extrae lo que necesitas. Esta secuencia maneja casi cualquier texto provisto por 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"User:   {username}")    # "carlos"
print(f"Domain: {domain}")      # "example.com"

Referencia de métodos

Método	Qué hace
`.lower()` / `.upper()`	Convierte a todo minúsculas / todo mayúsculas
`.title()` / `.capitalize()`	Capitaliza cada palabra / solo la primera
`.strip()` / `.lstrip()` / `.rstrip()`	Elimina espacio en blanco circundante
`.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)`	Se divide en una lista
`sep.join(iterable)`	Une elementos en una cadena
`.isdigit()` / `.isalpha()` / `.isalnum()`	Verificaciones de tipo de carácter

Cadenas de texto ​

Inmutabilidad ​

Indexación y corte ​

Métodos esenciales de cadenas ​

Mayúsculas y minúsculas ​

Espacios en blanco ​

Búsqueda ​

Reemplazo ​

División y unión ​

f-strings ​

Cadenas multilínea ​

Secuencias de escape ​

Verificar contenidos de cadenas ​

En la práctica ​

Referencia de métodos ​

Cadenas de texto

Inmutabilidad

Indexación y corte

Métodos esenciales de cadenas

Mayúsculas y minúsculas

Espacios en blanco

Búsqueda

Reemplazo

División y unión

f-strings

Cadenas multilínea

Secuencias de escape

Verificar contenidos de cadenas

En la práctica

Referencia de métodos