Cómo usar las cadenas de Python (str)

Crear una cadena

Una cadena (string) (str) es un tipo que representa una "secuencia de caracteres". En Python, cualquier valor envuelto en comillas es un str.

Hay tres formas de envolver una cadena, y eliges la que encaje con tu situación.

Cuando quieras incluir un salto de línea, puedes usar la secuencia de escape \n o envolver el texto entre comillas triples.

# Las comillas simples/dobles son para cadenas de una línea
fruit1 = 'apple'
fruit2 = "banana"

# Cuando el texto contiene ', envolver con " es más fácil
message = "it's a pen"

# Para incluir saltos de línea -> usa \n o comillas triples
text_a = "apple\nbanana\ngrape"
text_b = """apple
banana
grape"""

print(fruit1, fruit2)  # apple banana
print(message)         # it's a pen
print(text_a)          # se muestra en 3 líneas
print(text_b)          # mismo resultado que text_a

Prueba los tres tipos de comillas en la consola.

① Crea name = "Alice" y message = 'Hello', y luego usa print() con ambos.

② Usando \n, guarda "apple", "grape" y "lemon" en una sola variable y aplícale print() para que se muestre en 3 líneas.

③ Usando comillas triples ("""), guarda "apple", "grape" y "lemon" en una sola variable y aplícale print() para que se muestre en 3 líneas.

Extraer caracteres por posición (indexación y slicing)

También puedes sacar caracteres de una cadena por posición (un índice).

Lo importante es que los índices empiezan en 0. El primer carácter no está en la "posición 1": está en la posición 0.

Obtener un carácter — [i]

Escribe cadena[posición] para extraer el único carácter en esa posición.

Usa un número negativo para contar desde el final. -1 es el último carácter.

fruit = "lemon"  # l e m o n

print(fruit[0])   # l  (primero)
print(fruit[2])   # m  (3ro)
print(fruit[-1])  # n  (último)
print(fruit[-2])  # o  (2do desde el final)

# Salirse del rango lanza un error
# print(fruit[10]) # IndexError

word = "python" ya está definido.

① Imprime tanto el primer carácter como el último carácter de word con print().

② Imprime el carácter del medio (el 4º) de word, contando desde el inicio.

Extraer un rango — slicing con [a:b]

Escribe cadena[inicio:fin] para extraer todo desde la posición de inicio hasta la de fin, sin incluirla. Esto se llama slice.

El punto clave es el rango semiabierto: "hasta uno antes del final". [0:3] te da las posiciones 0, 1 y 2 (tres caracteres) y no incluye la 3.

msg = "0123456789"

print(msg[0:3])    # '012'   (no se incluye el 3)
print(msg[:4])     # '0123'  (desde el inicio)
print(msg[4:])     # '456789'(hasta el final)
print(msg[-3:])    # '789'   (últimos 3 caracteres)
print(msg[:-3])    # '0123456'(todo menos los últimos 3)

También puedes añadir un tercer número — [inicio:fin:paso] — para elegir caracteres de uno en uno saltando (o cada cierto número). [::2] toma uno sí y uno no.

Dicho esto, meter el paso y el rango en una sola línea se vuelve difícil de leer, así que para slices largos conviene partirlos en dos líneas.

msg = "0123456789"

# [::paso] salta a través de la cadena
print(msg[::2])       # '02468' (uno sí y uno no)
print(msg[::3])       # '0369'  (cada tercero)

# Separar el paso en su propia línea se lee mejor
head = msg[:6]        # '012345'
skip = head[::2]      # '024' (uno sí y uno no)
print(skip)

email = "alice@example.com" ya está definido.

① Usa un slice para extraer el nombre de usuario antes de @, es decir, solo "alice", e imprímelo (@ está en la posición 5).

② Usa [-3:] para extraer los últimos 3 caracteres "com" e imprímelo.

Métodos que transforman una cadena

Las cadenas vienen con funcionalidades integradas que producen una nueva cadena a partir de la original, y esas se llaman métodos.

Llamas a uno escribiendo variable.nombre_del_método(). El punto clave es que la cadena original nunca cambia: se devuelve una nueva cadena.

Igualar mayúsculas/minúsculas — upper / lower

upper() convierte todo a mayúsculas, y lower() convierte todo a minúsculas.

El uso más común es comparar cadenas ignorando mayúsculas y minúsculas. Los nombres y correos que escriben los usuarios suelen llegar con casings inconsistentes, así que normalizas los dos lados a la misma forma antes de comparar.

name = "Alice"

print(name.lower())    # alice
print(name.upper())    # ALICE
print(name)            # Alice  (el original no cambia)

# Comprueba si los dos nombres coinciden, ignorando mayúsculas/minúsculas
input_a = "ALICE"
input_b = "alice"
print(input_a.lower() == input_b.lower())  # True

Reemplazar contenido y recortar bordes — replace / strip

replace("antes", "después") devuelve una nueva cadena donde cada "antes" se ha cambiado por "después".

strip() es el método que quita los espacios en blanco de ambos extremos. Es perfecto para limpiar espacios sueltos que los usuarios pegan sin querer en un formulario.

greeting = "Hello World"
print(greeting.replace("World", "Python"))  # Hello Python
print(greeting)                             # Hello World (el original no cambia)

# Recorta espacios sueltos (solo los bordes; los de dentro se quedan)
raw = "  alice@example.com  "
print(raw.strip())        # 'alice@example.com'
print(len(raw))           # 21 (incluyendo espacios)
print(len(raw.strip()))   # 17 (los espacios se fueron)

Vamos a limpiar un correo escrito por un usuario.

① raw_email = " ALICE@Example.COM " ya está definido.

② Usa strip() para quitar los espacios en blanco de ambos extremos y lower() para pasar el texto a minúsculas, y luego guarda el correo limpio en clean_email.

③ Usa print() para mostrar tanto el original (raw_email) como la versión limpia (clean_email).

Métodos que inspeccionan una cadena

A continuación vienen los métodos que no cambian el valor: solo te cuentan algo sobre la cadena.

Cuentan apariciones de un carácter, revisan el inicio o el final, encuentran posiciones e inspeccionan qué tipo de caracteres hay dentro.

Revisar lo que hay dentro — count / startswith / endswith / find

• count("texto") — devuelve cuántas veces aparece texto, como número
• startswith("texto") — devuelve si la cadena empieza por texto (True / False)
• endswith("texto") — devuelve si la cadena termina con texto (True / False)
• find("texto") — devuelve la posición de la primera coincidencia. Si no encuentra nada, devuelve -1

msg = "abcCBAabc"

print(msg.count("a"))          # 3  (hay 3 letras a)
print(msg.count("abc"))        # 1  ('abc' aparece seguido solo una vez)

print(msg.startswith("abc"))   # True
print(msg.endswith("abc"))     # True

print(msg.find("CBA"))         # 3  (empieza en la posición 3)
print(msg.find("xyz"))         # -1 (no se encontró, así que -1)

endswith es la opción ideal para extensiones de archivo

Algo como filename.endswith(".png") te da una forma rápida de comprobar si un archivo es una imagen. Distingue entre mayúsculas y minúsculas, así que si la caja puede estar mezclada, tira de filename.lower().endswith(".png") para ir sobre seguro.

Vamos a armar una comprobación rápida para líneas que parezcan errores dentro de un log.

log = "ERROR: disk full at /tmp/log" ya está definido.

① Usa startswith para comprobar si log empieza por "ERROR", e imprime el resultado.

② Usa find para obtener la posición donde empieza la palabra "disk" dentro de log, e imprímela también.

Inspeccionar tipos de carácter — isdigit / isalpha / islower / isupper

La familia de métodos is...() devuelve True / False según si toda la cadena cumple la condición. Ten en cuenta que con un solo espacio o símbolo mezclado basta para que devuelvan False.

print("123".isdigit())       # True
print("12a".isdigit())       # False (hay una 'a' mezclada)

print("Tokyo".isalpha())     # True
print("Tokyo 2024".isalpha())# False (contiene un espacio y dígitos)

print("HELLO".isupper())     # True
print("Hello".islower())     # False

No uses isdigit para comprobar "¿esto se puede convertir en número?"

isdigit() solo devuelve True para cadenas que parezcan enteros no negativos. "-12" y "3.14" devuelven los dos False. Cuando necesites manejar cadenas con signos de menos o puntos decimales como números, olvídate de isdigit() y en su lugar pasa la cadena a int() / float() y usa manejo de excepciones para comprobar si funcionó.

Vamos a comprobar si una cadena que viene del usuario está en forma de número utilizable (un entero no negativo).

value = "42" ya está definido.

① Usa isdigit() para comprobar si value está formado solo por dígitos, y aplícale print() al resultado.

② Si el resultado es True, convierte value a número con int() e imprime el resultado de sumarle 10. Pista: isdigit() se puede usar directamente como condición en un if.

En este artículo aprendiste los tres tipos de comillas, cómo extraer caracteres con indexación y slicing, y un conjunto de métodos de transformación e inspección.

Las cadenas son uno de los tipos que más vas a usar en un programa. Los métodos que ves aquí son directamente reutilizables cuando empieces a manejar entradas del usuario en artículos posteriores, así que dedica un rato a ejecutar los ejemplos para coger soltura con ellos.