Cadenas en Python: crear, acceder, rebanar y manipular texto

Q: ¿Cómo unes cadenas en Python?

La concatenación consiste en unir cadenas. En Python se hace con el operador +. Es como encajar dos piezas de LEGO para formar algo más largo. La repetición usa el operador *. Repite una cadena el número de veces que le indiques. Es sorprendentemente útil para crear separadores, patrones o relleno.

Q: ¿Cómo sabes la longitud de una cadena?

La función len() te dice cuántos caracteres tiene una cadena. Eso incluye letras, números, espacios y caracteres especiales. Cada carácter cuenta.

Principiante25 min7 ejercicios135 XP

Esta lección es una traducción del original en inglés.Read in English Avisar de un error de traducción

Antes de empezar

Números en Python: enteros, decimales y cálculos que sí usarás

0/7 ejercicios

Piensa en tu teléfono. Casi todo lo que ves en la pantalla es texto: los nombres de tus contactos, los mensajes de tus amigos, los resultados de búsqueda, las notificaciones. Por dentro, todo ese texto se maneja con cadenas de texto.

Una cadena de texto (string) es la forma en que Python guarda y trabaja con texto. Puede ser una sola letra, una frase completa o incluso un libro entero. Si es texto, es una cadena.

En este tutorial aprenderás a crear cadenas, sacar caracteres concretos, cortarlas en trozos, unirlas y comprobar qué hay dentro de ellas. Son habilidades que usarás en casi todos los programas de Python que escribas.

¿Qué son las cadenas de texto en Python?

Una cadena es una secuencia de caracteres entre comillas. Puedes usar comillas simples, dobles o triples. Python las trata a todas como cadenas.

Imagina una cadena como un collar de cuentas. Cada cuenta es un carácter. Las comillas son el broche que mantiene el collar cerrado.

Tres formas de crear cadenas

# Single quotes

greeting = 'Hello, world!'

print(greeting) # Hello, world!

# Double quotes - exactly the same

greeting = "Hello, world!"

print(greeting) # Hello, world!

# Triple quotes - for multi-line text

poem = """Roses are red,

Violets are blue,

Python is awesome,

And so are you."""

print(poem)

Salida

Hello, world!
Hello, world!
Roses are red,
Violets are blue,
Python is awesome,
And so are you.

Las comillas simples y las dobles funcionan exactamente igual. La razón principal de tener las dos es la comodidad: si tu texto contiene un tipo de comilla, puedes encerrarlo con el otro.

Mezclar tipos de comillas

# Use double quotes when your text has single quotes

message = "It's a beautiful day"

print(message)

# Use single quotes when your text has double quotes

html = '<div class="container">Hello</div>'

print(html)

Salida

It's a beautiful day
<div class="container">Hello</div>

Incluso un par de comillas vacías crea una cadena. Una cadena vacía tiene cero caracteres, pero sigue siendo una cadena válida.

Cadenas vacías frente a cadenas con espacios

empty = ""

print(type(empty)) # <class 'str'>

print(len(empty)) # 0

# A string with just a space is NOT empty

space = " "

print(len(space)) # 1

Salida

<class 'str'>
0
1

¿Cómo accedes a un carácter concreto de una cadena?

Cada carácter de una cadena tiene un número de posición llamado índice. Puedes tomar cualquier carácter poniendo su índice entre corchetes.

Esto es lo importante: Python empieza a contar en 0, no en 1. El primer carácter está en el índice 0, el segundo en el índice 1, y así sucesivamente. A esto se le llama indexación desde cero.

Acceder a caracteres con índices positivos

word = "Python"

# Positive indexing (left to right)

# P y t h o n

# 0 1 2 3 4 5

print(word[0]) # P - first character

print(word[1]) # y - second character

print(word[5]) # n - last character

Salida

P
y
n

Piensa en los índices como en los números de las casas de una calle. La primera casa es la número 0, no la número 1. Al principio resulta raro, pero te acostumbrarás rápido.

¿Qué son los índices negativos en Python?

Python también te deja contar hacia atrás desde el final con índices negativos. El último carácter está en el índice -1, el penúltimo en el -2, y así sucesivamente.

Acceder a caracteres con índices negativos

word = "Python"

# Negative indexing (right to left)

# P y t h o n

# -6 -5 -4 -3 -2 -1

print(word[-1]) # n - last character

print(word[-2]) # o - second to last

print(word[-6]) # P - first character

Salida

n
o
P

¿Cómo funciona el rebanado (slicing) de cadenas en Python?

La indexación toma un carácter. El rebanado (slicing) toma un trozo de varios caracteres. Es como cortar una rebanada del centro de una barra de pan.

La sintaxis es string[start:stop]. Toma los caracteres desde start hasta stop, pero sin incluirlo. Esta regla de "hasta, pero sin incluir" es una de las cosas más importantes que debes recordar.

Rebanado básico de cadenas

text = "Hello, World!"

# text[start:stop] - includes start, excludes stop

print(text[0:5]) # Hello - characters 0,1,2,3,4

print(text[7:12]) # World - characters 7,8,9,10,11

print(text[0:1]) # H - just one character

Salida

Hello
World
H

Puedes omitir el inicio o el fin. Si omites el inicio, Python empieza desde el principio. Si omites el fin, Python llega hasta el final de la cadena.

Atajos de rebanado

text = "Hello, World!"

print(text[:5]) # Hello - from the beginning to index 5

print(text[7:]) # World! - from index 7 to the end

print(text[:]) # Hello, World! - a copy of the whole string

Salida

Hello
World!
Hello, World!

¿Cómo funciona el paso (step) en el rebanado?

Puedes añadir un tercer número: string[start:stop:step]. El paso (step) controla cuántos caracteres se saltan. Un paso de 2 toma un carácter sí y otro no.

Rebanar con un paso

text = "abcdefghij"

# Every other character

print(text[::2]) # acegi - step of 2

# Every third character

print(text[::3]) # adgj - step of 3

# Slice and step together

print(text[1:8:2]) # bdfh - start at 1, stop before 8, step 2

Salida

acegi
adgj
bdfh

El uso más famoso del paso es invertir una cadena. Un paso de -1 recorre toda la cadena hacia atrás.

Invertir una cadena con [::-1]

word = "Python"

# Reverse a string with [::-1]

print(word[::-1]) # nohtyP

# This works on any string

print("racecar"[::-1]) # racecar - a palindrome!

Salida

nohtyP
racecar

¿Cómo unes cadenas en Python?

La concatenación consiste en unir cadenas. En Python se hace con el operador +. Es como encajar dos piezas de LEGO para formar algo más largo.

Unir cadenas con +

first_name = "Ada"

last_name = "Lovelace"

# Concatenation with +

full_name = first_name + " " + last_name

print(full_name) # Ada Lovelace

# You can chain as many as you want

greeting = "Hello" + ", " + "world" + "!"

print(greeting) # Hello, world!

Salida

Ada Lovelace
Hello, world!

La repetición usa el operador *. Repite una cadena el número de veces que le indiques. Es sorprendentemente útil para crear separadores, patrones o relleno.

Repetir cadenas con *

# Repeat a string with *

print("Ha" * 3) # HaHaHa

print("-" * 30) # ------------------------------

print("abc " * 4) # abc abc abc abc

# Great for creating visual separators

title = "My Report"

print(title)

print("=" * len(title)) # =========

Salida

HaHaHa
------------------------------
abc abc abc abc 
My Report
=========

¿Cómo sabes la longitud de una cadena?

La función len() te dice cuántos caracteres tiene una cadena. Eso incluye letras, números, espacios y caracteres especiales. Cada carácter cuenta.

Medir la longitud de una cadena

message = "Hello, World!"

print(len(message)) # 13

# Spaces count!

print(len("a b c")) # 5 - three letters + two spaces

# Empty string has length 0

print(len("")) # 0

# Common use: get the last index

word = "Python"

last_index = len(word) - 1

print(word[last_index]) # n

Salida

¿Cómo compruebas si un texto está dentro de una cadena?

El operador in comprueba si una cadena aparece dentro de otra. Devuelve True o False. Es como usar Ctrl+F para buscar una palabra en un documento.

Buscar con el operador in

sentence = "The quick brown fox jumps over the lazy dog"

# Check if a word is in the sentence

print("fox" in sentence) # True

print("cat" in sentence) # False

print("quick" in sentence) # True

# Check if something is NOT in the string

print("cat" not in sentence) # True

Salida

True
False
True
True

Mayúsculas y minúsculas con in

# Case-sensitive gotcha

text = "Hello World"

print("hello" in text) # False - wrong case!

print("hello" in text.lower()) # True - convert to lowercase first

# Practical example: checking user input

user_answer = "Yes"

if "yes" in user_answer.lower():

print("User said yes!")

Salida

False
True
User said yes!

¿Qué son los caracteres de escape en las cadenas de Python?

Hay caracteres que no se pueden escribir directamente dentro de una cadena. ¿Cómo pones un salto de línea en una cadena? ¿Y un tabulador? Usas caracteres de escape: secuencias especiales que empiezan con una barra invertida \.

Caracteres de escape comunes

# \n - new line

print("Line 1\nLine 2\nLine 3")

# \t - tab

print("Name\tAge\tCity")

print("Alice\t25\tParis")

print("Bob\t30\tTokyo")

# \\ - literal backslash

print("File path: C:\\Users\\Documents")

# \" or \' - quote inside a string

print("She said \"hello\"")

Salida

Line 1
Line 2
Line 3
Name	Age	City
Alice	25	Paris
Bob	30	Tokyo
File path: C:\Users\Documents
She said "hello"

Aquí tienes una referencia rápida de los caracteres de escape que más vas a usar:

Escape	Qué hace	Ejemplo de salida
`\n`	Salto de línea	Texto en una línea nueva
`\t`	Tabulador	Añade un espacio de tabulación
`\\`	Barra invertida	Imprime una sola `\`
`\"`	Comilla doble	Imprime `"` dentro de una cadena entre `"`
`\'`	Comilla simple	Imprime `'` dentro de una cadena entre `'`

¿Por qué no puedes cambiar un carácter de una cadena en Python?

Las cadenas en Python son inmutables. Eso significa que, una vez creada una cadena, no puedes cambiar ninguno de sus caracteres. No puedes sustituir una letra ni corregir una errata dentro de una cadena que ya existe.

Piensa en una cadena como en un libro impreso. Puedes leer cualquier página, pero no puedes borrar una palabra y escribir otra. Si quieres cambiar algo, tienes que imprimir un libro nuevo.

Las cadenas no se pueden modificar directamente

word = "Hello"

# This will CRASH with a TypeError

try:

word[0] = "J" # Can't change individual characters!

except TypeError as e:

print(f"Error: {e}")

Salida

Error: 'str' object does not support item assignment

Entonces, ¿cómo "cambias" una cadena? Creas una cadena nueva con los cambios que quieres. El rebanado y la concatenación lo hacen fácil.

Falla: modificar una cadena directamente

word = "Hello"
word[0] = "J"  # TypeError!

Funciona: crear una cadena nueva

word = "Hello"
new_word = "J" + word[1:]
print(new_word)  # Jello

Ejercicios de práctica

¡Hora de practicar! Estos ejercicios cubren todo lo que viste en este tutorial. Empiezan fáciles y van subiendo de nivel.

Intenta resolver cada uno antes de mirar las pistas. Equivocarte y leer los mensajes de error es como de verdad se aprende.

Ejercicio 1: crea un saludo con concatenación

Escribe el código

Tienes dos variables: first_name con el valor "Ada" y last_name con el valor "Lovelace". Crea una variable llamada greeting que las combine en un mensaje y luego imprímela.

Salida esperada:

Hello, Ada Lovelace! Welcome to Python.

Usa la concatenación de cadenas (+) para construir el saludo.

first_name = "Ada"

last_name = "Lovelace"

# Create the greeting using concatenation (+)

# Print the greeting

Ejercicio 2: obtén el primer y el último carácter

Escribe el código

Tienes una variable word con el valor "Programming". Imprime el primer carácter y el último en líneas separadas.

Salida esperada:

P
g

Usa la indexación de cadenas para acceder a cada carácter.

word = "Programming"

# Print the first character

# Print the last character

Ejercicio 3: invierte una cadena

Escribe el código

Tienes una variable text con el valor "Python". Imprime la cadena al revés.

Salida esperada:

nohtyP

Usa el rebanado para invertirla en un solo paso.

text = "Python"

# Print the reversed string using slicing

Ejercicio 4: predice la salida del rebanado

Predice la salida

Sin ejecutar el código, predice qué imprimirá cada línea. Recuerda: el rebanado usa [start:stop], y stop queda excluido.

Escribe tus predicciones como comentarios y luego ejecuta el código para comprobarlas.

word = "Hello"

print(word[1:4]) # Your prediction:

print(word[:3]) # Your prediction:

print(word[2:]) # Your prediction:

Ejercicio 5: corrige el error al modificar una cadena

Corrige el error

Este código intenta corregir una errata cambiando un carácter directamente. Pero las cadenas son inmutables, así que falla.

Corrige el código para que imprima:

Hello World

Crea una cadena nueva en lugar de modificar la anterior.

message = "Hello Wurld"

# Fix the typo: change "u" to "o"

message[7] = "o"

print(message)

Ejercicio 6: comprueba si una palabra está en una frase

Escribe el código

Tienes una sentence y una search_word. Comprueba si la palabra buscada aparece en la frase (sin distinguir mayúsculas de minúsculas) e imprime el resultado.

Salida esperada:

True

Pasa las dos a minúsculas (o a mayúsculas) antes de comprobarlo.

sentence = "The quick brown Fox jumps over the lazy Dog"

search_word = "fox"

# Check if search_word is in sentence (case-insensitive)

# Print True or False

Ejercicio 7: extrae el dominio de una dirección de correo

Escribe el código

Tienes una dirección de correo guardada en email. Extrae solo el nombre de dominio (la parte que va después del símbolo @) e imprímelo.

Salida esperada:

gmail.com

Usa el método .find() para localizar el símbolo @ y luego usa el rebanado para extraer todo lo que hay después.

email = "alice@gmail.com"

# Find the position of the @ symbol

# Slice the string to get the domain

# Print the domain

Resumen: cadenas de texto en Python

Aquí tienes una referencia rápida de todo lo que aprendiste:

Concepto	Sintaxis	Ejemplo
Crear una cadena	`"text"` o `'text'`	`name = "Alice"`
Indexación	`string[i]`	`"Hello"[0]` da `"H"`
Indexación negativa	`string[-i]`	`"Hello"[-1]` da `"o"`
Rebanado	`string[start:stop]`	`"Hello"[1:4]` da `"ell"`
Rebanado con paso	`string[::step]`	`"Hello"[::-1]` da `"olleH"`
Concatenación	`+`	`"Hi" + " there"` da `"Hi there"`
Repetición	`*`	`"Ha" * 3` da `"HaHaHa"`
Longitud	`len(string)`	`len("Hello")` da `5`
Pertenencia	`in`	`"fox" in "a fox"` da `True`
Caracteres de escape	`\n`, `\t`, `\\`	Caracteres especiales dentro de cadenas

Lo esencial: las cadenas son inmutables. Puedes leer sus caracteres, rebanarlas, buscar en ellas y combinarlas, pero nunca puedes cambiar una cadena directamente. Cualquier "cambio" crea una cadena completamente nueva.

¿Qué sigue?

Ahora que sabes crear y rebanar cadenas, es hora de aprender a transformarlas. En el siguiente tutorial, [Métodos de cadenas en Python](/python/python-string-methods), descubrirás métodos integrados como .upper(), .replace(), .split() y .strip(), que hacen que trabajar con texto sea pan comido.

¿Qué son las cadenas de texto en Python?

¿Cómo accedes a un carácter concreto de una cadena?

¿Qué son los índices negativos en Python?

¿Cómo funciona el rebanado (slicing) de cadenas en Python?

¿Cómo funciona el paso (step) en el rebanado?

¿Cómo unes cadenas en Python?

¿Cómo sabes la longitud de una cadena?

¿Cómo compruebas si un texto está dentro de una cadena?

¿Qué son los caracteres de escape en las cadenas de Python?

¿Por qué no puedes cambiar un carácter de una cadena en Python?

Ejercicios de práctica

Resumen: cadenas de texto en Python

¿Qué sigue?

Tutoriales relacionados