Strings y f-strings

Los objetos str de Python representan texto Unicode. Las f-strings incrustan expresiones directamente en literales, haciendo que el formato sea legible y rápido. Saber cuándo usar bytes previene errores de codificación en los límites del sistema.

Receta

name = "Ada"
score = 97.456
line = f"{name:>10} | {score:.1f}%"
multiline = f"""Reporte para {name}
Puntuación: {score:.2f}"""
 
raw_path = r"C:\new\data\file.txt"

Cuándo usar esto:

• Construir mensajes de registro y salida visible para el usuario
• Analizar texto delimitado (similar a CSV) con split/strip
• Codificar texto para E/S de red o archivo
• Normalizar la entrada del usuario antes de la validación

Ejemplo de Trabajo

from pathlib import Path
 
def build_report(rows: list[dict[str, object]]) -> str:
    header = f"{'name':<12} {'role':<10} {'score':>6}"
    lines = [header, "-" * len(header)]
    for row in rows:
        lines.append(
            f"{row['name']:<12} {row['role']:<10} {row['score']:>6.1f}"
        )
    return "\n".join(lines)
 
def slugify(text: str) -> str:
    cleaned = text.strip().lower()
    for ch in " /_":
        cleaned = cleaned.replace(ch, "-")
    while "--" in cleaned:
        cleaned = cleaned.replace("--", "-")
    return cleaned.strip("-")
 
def read_utf8_file(path: Path) -> str:
    return path.read_text(encoding="utf-8")
 
def to_bytes_payload(message: str) -> bytes:
    return message.encode("utf-8")
 
if __name__ == "__main__":
    sample = [
        {"name": "Ada", "role": "admin", "score": 98.2},
        {"name": "Linus", "role": "dev", "score": 91.0},
    ]
    print(build_report(sample))
    print(slugify("  Hello World / API  "))
    print(to_bytes_payload("ok"))

Lo que esto demuestra:

• Las especificaciones de formato de f-string alinean columnas (:<12, :>6.1f)
• strip, lower y replace forman un pipeline simple para crear slugs
• Path.read_text(encoding="utf-8") evita sorpresas con la codificación predeterminada de la plataforma
• str.encode produce bytes para protocolos de red

Inmersión Profunda

Cómo Funciona

• Secuencias inmutables - Las strings no se pueden modificar in situ; los métodos devuelven nuevas strings.
• Puntos de código Unicode - str de Python 3 es Unicode; la indexación devuelve strings de un solo punto de código (en su mayoría).
• Evaluación de f-strings - Las expresiones se ejecutan en tiempo de ejecución; f"{x=}" para depuración muestra el nombre y el valor (3.8+).
• bytes vs str - bytes contiene valores de 0 a 255; decodificar con un códec explícito.
• Normalización - unicodedata.normalize ayuda a comparar caracteres visualmente similares.

Métodos Comunes

Notas de Python

text = "  hello  "
text.strip().casefold() == "HELLO".casefold()  # comparación insensible a mayúsculas/minúsculas
b"\xc3\xa9".decode("utf-8")  # bytes -> str
"résumé".encode("ascii", errors="replace")  # fallback con pérdida

Trampas

• Codificación implícita - open("f.txt") usa el valor predeterminado de la configuración regional en algunos sistemas. Solución: Siempre pasar encoding="utf-8".
• Concatenar bytes y str - b"hi" + "there" genera un TypeError. Solución: Codificar o decodificar explícitamente primero.
• Construcción de cadenas con valor predeterminado mutable - += masivo en bucles es lento para texto muy grande. Solución: Recopilar en una lista y usar "".join(lines).
• Comillas en f-strings - Las comillas anidadas pueden romper el análisis. Solución: Usar diferentes estilos de comillas o variables.
• Comparar Unicode visualmente - "café" != "café" con diferentes caracteres combinatorios. Solución: Normalizar antes de comparar.

Alternativas

Preguntas Frecuentes

Relacionado

• Archivos y E/S - lectura y escritura de texto codificado
• Números, Booleanos y Aritmética - especificaciones de formato numérico
• Comprensiones y Expresiones Generadoras - uniones de cadenas a partir de iterables
• arrays, bytes y memoryview - búferes binarios

Versiones de Stack: Esta página fue escrita para Python 3.14.0 (estable 3.14, mantenimiento 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, y uv 0.6+.