Trabaja con cadenas de caracteres en Python

Una cadena de caracteres es una secuencia de caracteres de tipo str. Puede contener un nombre, una oración, un código o ningún carácter. Python conserva los caracteres en orden, incluidos los espacios y los signos de puntuación.

Escribe el valor entre comillas del mismo tipo

Las comillas simples y dobles crean el mismo tipo de valor: 'hello' y "hello" son iguales. Las comillas externas marcan los límites; no son caracteres del valor. Elige unas comillas que permitan leer fácilmente las que haya dentro:

message = "It's late"
reply = 'She said "yes"'
empty = ""

En 'It's late', el apóstrofo cierra la cadena demasiado pronto y provoca un SyntaxError. Las comillas dobles lo resuelven, o puedes escribir 'It\'s late'. Usa comillas rectas en el código.

Almacena saltos de línea y barras inversas

Una secuencia de escape empieza con una barra inversa. Python interpreta \n como un salto de línea, \t como una tabulación y \\ como una barra inversa. Las comillas con escape, \' y \", introducen caracteres de comillas en el texto.

text = "a\nb"
print(len(text))  # 3
print(text)

La última llamada imprime a y b en líneas separadas. El valor tiene tres caracteres: a, un salto de línea y b. Las secuencias de escape se procesan cuando Python lee el literal. La consola muestra una representación con comillas y secuencias de escape donde hacen falta; print() muestra los propios caracteres. Por ejemplo, "\x41" se convierte en "A", por lo que la consola no necesita mostrar la secuencia de escape original.

Las comillas triples permiten que un literal ocupe varias líneas. Cada salto de línea de su interior se convierte en un carácter de salto de línea:

notice = """Door closed
Use side entrance"""

Una cadena sin procesar tiene una r antes de sus comillas. En r"C:\new", la barra inversa y la n se mantienen separadas, lo que da seis caracteres. En "C:\new", \n se convierte en un salto de línea, lo que da cinco. Los literales sin procesar son útiles cuando las barras inversas forman parte del texto.

Mide y combina texto

len() cuenta todos los caracteres, incluidos los espacios: len("Hi there!") es 9, y len("") es 0. Más exactamente, cuenta puntos de código Unicode. len("café") es 4 cuando é es un solo punto de código; len("👍🏽") es 2, aunque el emoji parezca un solo símbolo.

Usa + para concatenar cadenas y * para repetir una:

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

La concatenación no inserta nada por ti. Sin " ", los nombres se convierten en "AdaLovelace". Repetir "ab" cero veces da la cadena vacía.

Decide si los dígitos son texto o números

Ambos operandos de una concatenación de cadenas deben ser cadenas. "Age: " + 30 lanza TypeError; "Age: " + str(30) da "Age: 30". A la inversa, input() devuelve texto: "3" + "4" da "34". Para sumar sus valores numéricos, conviértelos primero: int("3") + int("4") da 7.

Un índice selecciona un carácter por su posición. Python empieza a contar en cero, por lo que la posición de un carácter es una unidad menor que su lugar en un conteo habitual desde la izquierda.

Dibuja las posiciones

Para word = "Python", cada carácter tiene un índice no negativo y un índice negativo:

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

Los corchetes situados después de la cadena seleccionan el carácter. El resultado es una cadena de longitud uno: Python no tiene un tipo independiente para caracteres. Puedes unir los caracteres seleccionados, por lo que word[0] + word[-1] da "Pn".

Para una longitud n, los índices válidos van de -n a n - 1 cuando n > 0. Los índices no negativos cuentan desde el inicio; los negativos cuentan desde el final. Un índice -k selecciona el mismo carácter que n - k; en esta palabra de seis caracteres, tanto -2 como 4 seleccionan "o".

Distingue la longitud del último índice

len(word) es 6, pero word[6] lanza IndexError: no hay un séptimo carácter. El último carácter es word[len(word) - 1] o, simplemente, word[-1]. Ir demasiado lejos desde cualquiera de los extremos falla; word[-7] también lanza IndexError.

Un índice debe ser un número entero. word[1.0] lanza TypeError aunque el número de coma flotante tenga un valor entero. Usa // al calcular una posición central:

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

El operador / produciría 1.5, que no puede usarse como índice de una cadena. Para una longitud impar, len(word) // 2 selecciona el carácter central. Para una longitud par, selecciona el de la derecha de los dos caracteres centrales: "Python"[3] es "h".

Construye iniciales a partir de los primeros caracteres

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Cada nombre aporta su carácter del índice 0. Usar first[-1] aportaría "e", la última letra. Este método requiere que cada nombre tenga al menos un carácter.

Comprueba si la entrada está vacía antes de usar un índice

La cadena vacía tiene longitud cero y ningún índice de carácter válido. ""[0] lanza IndexError. Una comprobación de longitud puede evitar que un programa lea un carácter que no existe:

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

Python evalúa and de izquierda a derecha. Si la comprobación de longitud es falsa, omite line[0]. Invertir esas dos comprobaciones intentaría primero el acceso mediante el índice inseguro. Cuando solo necesitas saber si una línea empieza por "#", line.startswith("#") también funciona con una entrada vacía y devuelve False.

Un segmento selecciona una secuencia continua de caracteres y la devuelve como una cadena. Te permite tomar un prefijo, eliminar un final o separar campos que ocupan posiciones fijas.

Se incluye el inicio y se excluye el final

Escribe text[start:stop]. Con s = "Monty Python", s[0:5] da "Monty", y s[6:12] da "Python". El espacio está en el índice 5, por lo que el segundo segmento empieza en 6.

Imagina los números del segmento como huecos. El hueco 0 está antes del primer carácter y el hueco 5 está después de los primeros cinco. Tomar todo lo que hay entre ellos da cinco caracteres. Para 0 <= start <= stop <= len(text), la longitud es stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

La posición final es la primera posición que queda fuera. Sumar uno al último índice deseado incluye ese último carácter.

Omite un límite

En cualquier posición de división k, s[:k] + s[k:] devuelve s. Los segmentos se encuentran en el mismo hueco, sin que falte ni se repita ningún carácter.

Los límites de un segmento que superan los extremos se ajustan. "cat"[1:100] es "at"; "cat"[5:] es "". Para un segmento que avanza hacia delante, un inicio situado en el límite final o después da una cadena vacía, como en s[4:2]. A diferencia de un índice de un solo carácter, un segmento fuera de rango no lanza IndexError.

Elige un paso

La tercera posición de text[start:stop:step] establece cuánto avanzar entre las posiciones seleccionadas:

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

Un paso negativo retrocede. Con ambos límites omitidos, [::-1] empieza en el último carácter y visita todos los caracteres en orden inverso. Un paso de cero lanza ValueError. La dirección debe concordar con los límites: la regla anterior del resultado vacío cuando «el inicio está en el límite final o después» corresponde a un paso positivo.

Aplica segmentos a una estructura fija

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

Las posiciones funcionan porque esta estructura siempre usa cuatro dígitos para el año y dos para el mes y el día. El texto con campos de longitud variable necesita una búsqueda o una división.

La inversión también permite comprobar si una palabra es un palíndromo: word == word[::-1]. "level" cumple la condición, pero "Level" no, porque se distingue entre mayúsculas y minúsculas. Asigna clean = word.lower() y comprueba clean == clean[::-1] para ignorar esa distinción.

Usa un bucle cuando haya que tomar una decisión sobre cada carácter. El bucle puede contar coincidencias, usar sus posiciones, detenerse en la primera coincidencia o recoger los caracteres que deban formar parte de un resultado.

Visita los caracteres directamente

for ch in "hi!":
    print(ch)

El cuerpo se ejecuta tres veces, con ch igual a "h", "i" y "!" por turno. La cadena vacía ejecuta el cuerpo cero veces. Un bucle que recorre directamente los caracteres no necesita un índice cuando solo usas el carácter actual.

Para contar, inicializa el contador antes del bucle e increméntalo solo cuando se supere la comprobación:

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

Convertir a minúsculas hace que también coincidan las vocales mayúsculas. La cadena de comprobación define las vocales que se cuentan; no incluye y. Reiniciar count dentro del bucle haría perder el total de las pasadas anteriores.

Usa posiciones cuando importen los caracteres vecinos

range(len(text)) proporciona los índices desde cero hasta el último índice válido. Para una tarea que necesite tanto la posición como el carácter, enumerate(text) los proporciona juntos:

for i, ch in enumerate("abc"):
    print(i, ch)

Esto imprime 0 a, después 1 b y después 2 c. Las dos variables del bucle reciben el índice y el carácter de cada par.

Para comparar caracteres vecinos, el último índice no puede ser la posición actual porque no tiene un carácter siguiente:

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

Las coincidencias son oo, kk y ee. Con range(len(text)), la última pasada intentaría acceder a text[len(text)] y lanzaría IndexError.

Gestiona una posición con while

i = 0
while i < len(text):
    print(text[i])
    i += 1

La comprobación usa estrictamente <: la posición len(text) está más allá del final. El incremento acerca el bucle a su terminación; omitirlo hace que se lea el mismo carácter indefinidamente si el texto no está vacío. Para recorrer hacia atrás, empieza en len(text) - 1, continúa mientras i >= 0 y resta uno en cada pasada.

Busca o recoge caracteres

Para encontrar el primer dígito de "Room 42B", detente después de usar una coincidencia:

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Sin break, se imprimirían ambos dígitos. Para una comprobación sencilla de presencia, "4" in text ya responde sí o no.

Para recoger texto, empieza con result = "" y añade cada carácter deseado. Para "a b c", añadir solo cuando ch != " " construye "abc". Asignar ch = ch.upper() dentro de un bucle cambia solo la variable del bucle; no cambia los caracteres almacenados en text.

Las cadenas son inmutables: sus caracteres no pueden cambiarse una vez que existe la cadena. Un programa que parece editar texto está construyendo otra cadena y eligiendo qué variable se referirá a ella.

Lee un carácter, pero no le asignes un valor

name = "Jane"
name[0] = "D"  # TypeError

El acceso mediante el índice permite leer "J", pero no puede ser el destino de una asignación. del name[0] también lanza TypeError. Para obtener "Dane", combina el primer carácter deseado con el final sin modificar:

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

Python evalúa primero el lado derecho y produce una cadena nueva. Después hace que name se refiera a ese resultado.

Sustituye o inserta en una posición conocida

Para un índice no negativo válido i, estas expresiones usan segmentos distintos en la parte derecha:

La sustitución omite el carácter anterior; la inserción lo conserva. Con text = "cat", i = 1 y new = "X", la sustitución da "cXt", mientras que la inserción da "cXat".

Convierte un índice negativo en su equivalente no negativo antes de usar este patrón de sustitución. Para el último carácter de "cat", i = len(text) - 1 es 2. Si introduces -1 directamente en text[i + 1:], se convierte en text[0:], lo que añade toda la cadena anterior y da "caXcat".

Conserva el resultado de un método

Los métodos de transformación siguen la misma regla de inmutabilidad:

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

La primera llamada calcula un resultado que el programa descarta. La asignación conserva el segundo resultado. Los métodos de cadena nunca cambian la cadena original, pero sus tipos de retorno varían: upper() devuelve una cadena, find() un número entero e isdigit() un booleano.

Sigue dos nombres que se refieren a un valor

Tras a = "cat" y b = a, ambas variables se refieren a "cat". Ejecutar a = a + "s" da a a el nuevo valor "cats"; b sigue refiriéndose a "cat". Ningún carácter de la cadena anterior compartida ha cambiado. a += "s" realiza el mismo tipo de reasignación para una cadena.

Construye un valor modificado en un bucle

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Cada pasada amplía masked con un carácter elegido. Colocar cada carácter delante, con result = ch + result, invierte el texto: las pasadas por "drawer" construyen "d", "rd", "ard", "ward", "eward" y "reward".

La concatenación repetida es práctica para ejemplos breves. Cuando las partes ya existen en una lista, "".join(pieces) construye directamente un resultado y también puede colocar un separador entre ellas.

Un método es una función asociada a un valor. Los métodos de cadena realizan tareas habituales, como cambiar entre mayúsculas y minúsculas, recortar los extremos de los datos de entrada y sustituir texto. Cada llamada devuelve un resultado y deja intacta la cadena original.

Llama a un método con notación de punto

Escribe value.method(arguments), como en "hello".upper(). Los paréntesis hacen que se realice la llamada. name.upper sin paréntesis se refiere al propio método; no produce texto en mayúsculas. Escribir upper(name) no encuentra una función independiente llamada upper. Usa dir("") para enumerar los métodos de cadena y help(str.upper) para leer sobre uno.

Elige una operación de mayúsculas y minúsculas

capitalize() cambia el primer carácter y pone el resto en minúsculas; title() vuelve a empezar palabras después de caracteres que no son letras. Esto hace que "they're".title() se convierta en "They'Re", por lo que puede ser necesario revisar el uso automático de mayúsculas iniciales.

Para comparar sin distinguir entre mayúsculas y minúsculas, casefold() maneja más casos entre distintos idiomas que lower(). "Straße".lower() es "straße", mientras que "Straße".casefold() es "strasse". Aplica esta normalización a ambas cadenas antes de compararlas.

Limpia los extremos del texto

strip() elimina los caracteres de espacio en blanco iniciales y finales, incluidos espacios, tabulaciones y saltos de línea. Conserva el espaciado interno: " New York \n".strip() es "New York". lstrip() limpia solo el extremo izquierdo; rstrip() limpia solo el derecho.

Con un argumento, la eliminación retira repetidamente de los extremos cualquiera de esos caracteres. No elimina una palabra exacta:

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

La t final de report también pertenece al conjunto de caracteres que se eliminan, por lo que desaparece. removeprefix() y removesuffix() eliminan un texto exacto en un extremo; están disponibles en Python 3.9 y versiones posteriores.

Sustituye coincidencias y encadena cambios

replace(old, new) sustituye cada coincidencia exacta. Un tercer argumento limita cuántas coincidencias cambian: "a-b-c".replace("-", "", 1) da "ab-c". Una sustitución vacía elimina las coincidencias. Se distingue entre mayúsculas y minúsculas, por lo que "Cat cat".replace("cat", "dog") da "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

Las llamadas se ejecutan de izquierda a derecha: strip() devuelve "YES" y después lower() devuelve "yes". Un encadenamiento funciona cuando el siguiente método es compatible con el tipo del resultado anterior. El resultado de una búsqueda es un número entero, por lo que no admite métodos de limpieza de cadenas.

Para añadir relleno, "7".zfill(3) da "007", "Total".ljust(8) añade tres espacios a la derecha y "Hi".center(8, "*") da "***Hi***". rjust() añade relleno a la izquierda. Estas anchuras son mínimas; el texto más largo se conserva completo.

La búsqueda puede responder a tres preguntas distintas: si aparece un texto, dónde empieza y cuántas veces aparece. Elige el resultado que se ajuste a la decisión que deba tomar tu programa.

Elige un resultado de búsqueda

Una subcadena es una secuencia de caracteres consecutivos. "py" in "happy" es True, pero "hpy" in "happy" es False. Las coincidencias distinguen entre mayúsculas y minúsculas: "Py" in "python" es False. not in invierte la comprobación de presencia. La cadena vacía aparece en todas las cadenas.

Encuentra la aparición adecuada

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

La posición inicial opcional omite los posibles resultados anteriores. El índice devuelto sigue contando desde el principio de la cadena completa. index() devuelve la misma posición cuando hay una coincidencia, pero el error que lanza si no la hay lo hace útil cuando la ausencia indica un problema inesperado.

Comprueba una posición antes de extraer segmentos

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

La búsqueda devuelve 11. El primer segmento se detiene antes de @; el segundo empieza un carácter después. Si faltara el marcador, at sería -1. Usarlo como límite de un segmento seleccionaría texto cercano al final sin avisar, así que maneja la ausencia del marcador antes de extraer las partes.

No uses if text.find("x"): como comprobación de presencia. Una coincidencia en el índice 0 se considera falsa en una condición, mientras que el valor -1 que indica ausencia se considera verdadero. Usa if "x" in text: o compara la posición explícitamente con -1.

Busca desde un marcador conocido

Para line = "Order #4521 shipped", el número va después de # y termina en el espacio siguiente:

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Aquí existen ambos marcadores. Empezar la segunda búsqueda en start omite el espacio anterior, situado después de Order. Si pueden faltar marcadores, comprueba el resultado original de cada búsqueda antes de sumar uno o extraer segmentos; sumar uno a -1 ocultaría el fallo de la búsqueda al convertirlo en 0.

Cuenta coincidencias completas

"banana".count("a") es 3, y "banana".count("ana") es 1. Las dos coincidencias posibles de ana se solapan, por lo que count() no cuenta ambas. Del mismo modo, "aaaa".count("aa") es 2.

Para ignorar las diferencias entre mayúsculas y minúsculas, busca en una versión convertida, como "python" in sentence.lower(). La búsqueda sigue buscando coincidencias exactas dentro de esa versión. Los conteos y las comprobaciones de presencia pueden usar directamente la cadena convertida; un índice pertenece a la cadena concreta en la que se ha buscado.

Las comprobaciones de cadenas devuelven booleanos que pueden guiar una condición. Te ayudan a aceptar datos de entrada que cumplan una regla y a comparar texto de manera uniforme.

Comprueba los extremos o los caracteres

startswith() y endswith() comprueban texto exacto en los extremos. Una tupla permite que una comprobación acepte varios finales: name.endswith((".jpg", ".png")). "photo.PNG", con su extensión en mayúsculas, no supera esa comprobación a menos que la conviertas primero a minúsculas.

Las cinco devuelven False para "". Las letras no tienen que ser del inglés: "café".isalpha() es True. El espacio de "hello world" hace que isalpha() sea falso.

isupper() e islower() examinan los caracteres que tienen mayúscula y minúscula y requieren al menos uno. "ABC1".isupper() es True; el dígito no invalida las letras mayúsculas. "123" no tiene caracteres con mayúscula y minúscula, por lo que ambas comprobaciones son falsas.

Valida antes de convertir

Una comprobación de dígitos no describe todos los números que Python puede leer. "-5".isdigit(), "3.5".isdigit() y " 42".isdigit() son falsas porque un signo, un punto o un espacio no son dígitos. Además, "²".isdigit() es verdadera aunque int("²") falle. isdecimal() rechaza ese superíndice y resulta adecuada para introducir un número entero no negativo escrito solo con dígitos.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

La comprobación de la cadena se ejecuta primero. Cuando es falsa, and omite la conversión, evitando errores con entradas vacías o no numéricas. " 12 " se convierte en "12" y supera la comprobación; "0" se convierte sin problemas, pero no supera la comprobación de valor positivo. Esta regla rechaza deliberadamente las entradas con signo o punto decimal.

Una regla para nombres de usuario puede combinar comprobaciones de longitud y caracteres: 3 <= len(name) <= 12 and name.isalnum(). "ada99" se acepta, "ada 99" no supera la comprobación de caracteres y "ad" no supera la de longitud.

Compara texto limpio

La igualdad requiere los mismos caracteres en el mismo orden. "Yes" == "yes" y "yes " == "yes" son falsas. Para respuestas en las que deban ignorarse las diferencias entre mayúsculas y minúsculas y los espacios en blanco de los extremos, compara typed.strip().casefold() con expected.strip().casefold().

La ordenación funciona carácter a carácter. El primer punto de código Unicode distinto decide. ord("A") es 65, ord("Z") es 90 y ord("a") es 97; chr(97) da "a". Por tanto, "Zebra" < "apple" es verdadera. Cuando una cadena es un prefijo de la otra, la más corta va primero: "app" < "apple".

Las cadenas de dígitos también usan el orden de los caracteres: "10" < "9" es verdadera porque "1" va antes que "9". Convierte los valores a números al comparar cantidades. Las letras acentuadas también requieren cuidado: ord("é") es 233, por lo que "école" > "zoo" es verdadera. Esta ordenación incorporada sigue los puntos de código, no el orden de un diccionario de un idioma.

split() convierte una cadena en una lista de cadenas. Una lista es una colección ordenada escrita entre corchetes. Puedes leer un elemento mediante su índice, recorrer los elementos con un bucle o contarlos con len().

Elige espacios en blanco o un separador exacto

Sin argumentos, split() trata una secuencia de caracteres de espacio en blanco como un solo límite e ignora los de ambos extremos:

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

Con un separador explícito, cada aparición exacta produce un corte. Los separadores consecutivos conservan un campo vacío:

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

El tercer elemento vacío puede representar un valor que se ha dejado en blanco. Sigue contando como un elemento de la lista.

Un separador puede contener varios caracteres, pero todos deben coincidir. Si no aparece ningún separador, el resultado contiene la cadena original completa como un solo elemento. Por tanto, dividir por coma y espacio es distinto de dividir por una coma.

Limita cuánto texto se divide

El segundo argumento, maxsplit, limita el número de cortes, no el número de elementos resultantes:

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() empieza por la izquierda; rsplit() empieza por la derecha. Un corte desde la derecha separa la última extensión del archivo sin cortar en los puntos anteriores.

Lee campos y convierte cantidades

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

La salida es "Ada Lovelace was born in 1815.". La comprobación de longitud evita que un elemento ausente provoque IndexError. No comprueba que el año sea numérico; eso necesita una regla de entrada independiente cuando los datos puedan ser inválidos.

Cada parte obtenida al dividir empieza siendo una cadena. Para sumar "3 14 15", inicializa total = 0, recorre line.split() con un bucle y añade int(part). El resultado es 32; concatenar las partes sin convertir uniría los dígitos.

Un separador explícito conserva los espacios de alrededor. "a, b".split(",") da ["a", " b"]. Llama a strip() en cada parte si no quieres esos espacios.

Reconoce dos resultados relacionados

splitlines() separa por los saltos de línea: "line one\nline two".splitlines() da dos cadenas. partition("=") siempre devuelve una tupla de tres partes: el texto anterior al primer separador, el separador y el texto posterior. "user=ada".partition("=") da ("user", "=", "ada"); con "user", da ("user", "", "").

join() construye una cadena a partir de una secuencia de cadenas. La cadena situada antes del punto proporciona el separador, que aparece entre elementos contiguos.

Pon primero el separador

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Lee esto como «usa coma y espacio para unir los colores». No hay separador antes del primer elemento ni después del último. Puedes cambiar la estructura de la salida modificando solo el separador:

join() pertenece a la cadena separadora. Escribir ["a", "b"].join(",") lanza AttributeError porque la lista no tiene un método join. Una sola llamada también se adapta al número de partes; no necesitas escribir una nueva cadena de operaciones + para cada longitud de lista distinta.

Convierte primero las partes que no sean cadenas

Todas las partes deben ser ya cadenas. ", ".join([1, 2, 3]) lanza TypeError. map(str, items) aplica str() a cada elemento, por lo que esto funciona:

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

El str que se pasa a map() es la función de conversión. join() recibe las partes convertidas y devuelve una cadena.

Una cadena es en sí misma una secuencia de cadenas de un carácter, por lo que " ".join("ABC") da "A B C". Esto puede resultar útil, pero pasar una sola palabra cuando querías pasar una lista de palabras coloca separadores entre sus caracteres.

Reorganiza el espaciado y los separadores

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

Primero, la división por espacios en blanco produce las tres palabras. Unirlas con un espacio establece una separación uniforme y no deja espacios en los extremos. El espaciado original se pierde en el paso de división.

Con un separador explícito, los campos vacíos conservan información suficiente para reconstruir el texto exacto. Si s = "a,,b,", entonces s.split(",") da ["a", "", "b", ""], y ",".join(...) vuelve a dar "a,,b,". El separador debe ser el mismo para lograr esa reconstrucción exacta.

Cambiar el separador cambia la estructura: "-".join("2026/07/04".split("/")) da "2026-07-04". Aquí, replace("/", "-") también es una solución directa.

Recoge un resultado breve a partir de palabras

Para formar una sigla, divide "portable network graphics", empieza con acronym = "" y añade word[0].upper() por cada palabra. La división por espacios en blanco proporciona palabras no vacías, por lo que sus primeros caracteres existen. Esto construye "PNG". Si las letras ya están en una lista, ".".join(["P", "N", "G"]) construye "P.N.G" sin punto final.

Una cadena formateada es un literal de cadena con f o F antes de su comilla de apertura. En su interior, las llaves contienen expresiones cuyos valores se insertan en el texto.

Inserta variables y expresiones

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Los números se convierten en texto automáticamente dentro de un campo. El mismo mensaje podría usar concatenación y str(age), pero la cadena formateada mantiene visible la estructura final en un solo lugar.

Las llaves pueden contener operaciones aritméticas, llamadas a métodos o llamadas a funciones:

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

Python evalúa cada expresión al ejecutar la línea. Una cadena guardada no permanece conectada a las variables usadas para construirla. Si qty cambia después de construir message, esa cadena conserva los caracteres que ya tiene.

Distingue el texto normal de los campos

Sin el prefijo, "Hello {name}" es texto normal y conserva sus llaves. La falta de f es una causa habitual de que un programa imprima el nombre de la variable en lugar de su valor. Con el prefijo, un nombre al que no se haya asignado un valor lanza NameError al evaluar la expresión.

Para mostrar una llave literal, duplícala:

x = 5
print(f"{{x}} = {x}")  # {x} = 5

Las llaves duplicadas proporcionan el texto literal {x}. El par simple que rodea la última x proporciona su valor.

Facilita la lectura de las expresiones con comillas

Usa el otro tipo de comillas dentro de un campo:

print(f"Shout: {'hi'.upper()}")  # Shout: HI

Este estilo funciona en todas las versiones de Python con cadenas formateadas, que se introdujeron en la versión 3.6. Python 3.12 y versiones posteriores también permiten reutilizar dentro del campo el tipo de comillas externas. Las secuencias de escape siguen funcionando en las cadenas formateadas: f"Name: {name}\nAge: {age}" imprime en dos líneas.

Para mostrar información rápidamente durante la depuración, Python 3.8 y versiones posteriores aceptan = después de una expresión. Con x = 5, f"{x=}" da "x=5"; con total = 12, f"{total = }" da "total = 12". Los espacios escritos alrededor de la expresión y del signo igual aparecen en la salida.

Interpreta estilos de formato anteriores

El código Python existente puede construir el mismo texto de otras maneras:

str.format() rellena los campos entre llaves con sus argumentos. Los campos numerados pueden reutilizar un argumento: "{0} {1} {0}".format("a", "b") da "a b a". En el formato con porcentaje, %s inserta texto y %d un número entero. Reconocer esos campos te ayuda a leer un programa aunque se escribiera antes de que las cadenas formateadas fueran habituales.

Un especificador de formato controla cómo se muestra un valor. Coloca dos puntos después de la expresión y, a continuación, las instrucciones: f"{value:spec}". Dar formato devuelve texto y deja intacto el valor numérico original.

Establece las cifras decimales y comprende el redondeo

.Nf muestra exactamente N dígitos después del punto decimal. f"{3.14159:.2f}" da "3.14", f"{2/3:.3f}" da "0.667" y f"{5:.2f}" da "5.00". .0f no muestra punto decimal: f"{7.6:.0f}" da "8".

El redondeo usa el valor realmente almacenado. La mayoría de las fracciones decimales son aproximaciones binarias muy cercanas. El número de coma flotante 2.675 está ligeramente por debajo de ese decimal exacto, por lo que f"{2.675:.2f}" da "2.67". Los valores situados exactamente a mitad de camino se redondean hacia una cifra final par: 0.125 se muestra como "0.12", mientras que 0.375 se muestra como "0.38" con dos cifras decimales. f"{2.5:.0f}" da "2". Los programas que necesitan cálculos monetarios exactos suelen almacenar los centavos enteros como números enteros.

Añade agrupación y porcentajes

Una coma agrupa los miles; el punto introduce la precisión decimal. Para un importe en dólares, deja el signo del dólar fuera del campo: con amount = 1250.5, f"${amount:,.2f}" da "$1,250.50".

El tipo % multiplica por 100 y añade %. Usa una fracción como 0.256 para mostrar 25.6%. Si proporcionas 25.6, el porcentaje mostrado se multiplica de nuevo. Sin una precisión explícita, % muestra seis cifras decimales.

Da formato a números enteros y partes de fechas

d es para números enteros. f"{42:d}" funciona, pero f"{3.0:d}" lanza ValueError porque un número de coma flotante no es un número entero. Un cero inicial antes de una anchura añade relleno con ceros; un signo más solicita un signo visible:

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

Para el mes 7, el día 4 y el año 2026, f"{month:02d}/{day:02d}/{year}" construye "07/04/2026". Para la hora 9 y el minuto 5, f"{hour}:{minute:02d}" construye "9:05". El relleno con ceros evita que un minuto de un dígito aparezca como "9:5".

Combina las instrucciones en orden

El orden es relleno, alineación, signo, cero, anchura, agrupación, precisión y tipo. Puedes omitir las partes que no necesites. f"{12345.678:>12,.2f}" usa alineación a la derecha, anchura 12, agrupación con comas y dos decimales, lo que da " 12,345.68".

La precisión puede proceder de otra variable: con places = 3, f"{3.14159:.{places}f}" da "3.142". Los mismos especificadores funcionan en format(value, spec) y en los campos de str.format(). Conserva el número original para los cálculos; round(value, 2) devuelve un número redondeado cuando eso es lo que necesita el cálculo.

Una anchura de campo reserva un número mínimo de posiciones de caracteres para un valor. Combinar anchuras hace que las tablas breves y los recibos sean legibles en una terminal.

Elige la anchura y la alineación

Las cadenas se alinean a la izquierda de forma predeterminada y los números a la derecha. f"{'cat':6}" da "cat ", mientras que f"{42:6}" da " 42". Usa un carácter de alineación para elegirla explícitamente:

Cuando al centrar queda un número impar de espacios, la alineación de las cadenas formateadas coloca el espacio adicional a la derecha: f"{'hi':^7}" da " hi ".

La anchura es un mínimo. f"{'elephant':4}" sigue dando "elephant"; no recorta la palabra. Por tanto, una entrada larga puede desalinear las columnas posteriores.

Añade un carácter de relleno o limita el texto

Un carácter de relleno va inmediatamente antes de la alineación. f"{'hi':*^10}" da "****hi****", y f"{7:0>3}" da "007". El relleno necesita un carácter de alineación. f"{'':-^20}" rellena un campo vacío con veinte guiones.

La precisión de cadena limita el número de caracteres que se muestran:

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

La precisión limita primero el texto mostrado a cuatro caracteres; después, la anchura lo rellena hasta diez. Usa una anchura y una precisión iguales cuando el texto deba permanecer dentro de una columna fija. El valor original de place sigue siendo "Washington".

Construye una fila de un recibo

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

El resultado es "Apples 3 13.50". El campo del artículo tiene seis letras y dos espacios. El campo de cantidad añade tres espacios antes de 3. El campo de importe añade cuatro espacios antes de 13.50, que tiene cinco caracteres. Juntos, los campos ocupan 21 caracteres.

Reutiliza esas anchuras para el pan (1 a 2,25) y el café (2 a 11,00). Sus filas son "Bread 1 2.25" y "Coffee 2 22.00". Una fila de total puede combinar los dos primeros campos:

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

El campo de importe empieza en la misma posición y tiene la misma precisión decimal, por lo que los importes quedan alineados.

Adapta la estructura a su presentación

Elige anchuras que dejen espacio para las entradas más largas y su separación, o acorta el texto de forma deliberada. Una variable puede proporcionar una anchura: con w = 10, f"{name:<{w}}" rellena name hasta diez caracteres.

Las columnas basadas en caracteres necesitan una fuente monoespaciada, como la que usa una terminal. Para añadir relleno fuera de una cadena formateada, ljust() y rjust() se comportan como < y >. center() y ^ centran el texto, pero pueden repartir de forma distinta un relleno impar: "hi".center(7) da " hi ", mientras que f"{'hi':^7}" da " hi ".