Redirigir la salida de impresión a un archivo en Python

Para guardar texto en un archivo con Python, ábrelo con open() y escribe mediante el objeto de archivo que devuelve. Usa el modo "w" para crear o reemplazar un archivo, o "a" para añadir contenido al final. Una instrucción with cierra el archivo al terminar el bloque.

Este ejemplo escribe un mensaje en report.txt y luego muestra el texto guardado:

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "report.txt"
    with path.open("w", encoding="utf-8") as file:
        file.write("Monthly report\nRevenue: 1200\n")
    print(f"Saved to {path.name}:")
    print(path.read_text(encoding="utf-8"), end="")

Saved to report.txt:
Monthly report
Revenue: 1200

Los siguientes ejemplos muestran cuándo usar write(), print(), la redirección de la salida estándar, writelines() o la interfaz de rutas de pathlib. La mayoría de los ejemplos usan una instrucción with para cerrar el archivo automáticamente; el ejemplo con sys.stdout restaura el flujo anterior y cierra el archivo de forma explícita.

Escribir texto con open() y write()

open() determina cómo se abre un archivo; write() es un método del objeto de archivo que devuelve. El modo "w" crea un archivo o reemplaza su contenido existente. El modo "a" crea el archivo si es necesario y añade texto al final. Son modos de apertura de archivos, no operaciones de write().

write() acepta una cadena y no añade un salto de línea. Incluye \n donde quieras empezar una línea nueva. El valor devuelto es el número de caracteres escritos.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "notes.txt"
    with path.open("w", encoding="utf-8") as file:
        file.write("First line\n")
        file.write("Second line\n")
    print(path.read_text(encoding="utf-8"), end="")

First line
Second line

Para añadir contenido, cambia el modo a "a". Por ejemplo, with open("notes.txt", "a", encoding="utf-8") as file: file.write("Next entry\n") agrega una línea después del contenido existente. La ruta se resuelve en relación con el directorio de trabajo actual del programa, salvo que indiques otra ruta.

Imprimir en un archivo con print()

Usa print(..., file=file_object) cuando quieras el formato habitual de print(), pero necesites guardar su salida en un archivo. Convierte los objetos en texto, separa varios valores con un espacio de forma predeterminada y añade un salto de línea también de forma predeterminada. Puedes cambiar esas opciones con sep y end.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "summary.txt"
    with path.open("w", encoding="utf-8") as file:
        print("Count:", 3, file=file)
        print("Ready:", True, file=file)
    print(path.read_text(encoding="utf-8"), end="")

Count: 3
Ready: True

El bloque with cierra el archivo cuando termina la impresión. No hace falta llamar a close() dentro de ese bloque: al salir de él, Python cierra el archivo automáticamente.

Redirigir la salida estándar con sys.stdout

sys.stdout es el flujo que usa print() cuando no se proporciona el argumento file. Asignar un archivo a sys.stdout redirige la salida estándar del proceso, así que guarda y restaura el flujo anterior y cierra el archivo. Para una redirección habitual y limitada a un bloque, es preferible usar contextlib.redirect_stdout() en la siguiente sección. Consulta la referencia de sys.stdout; por ahora, no hay un destino en español disponible.

import sys
from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "log.txt"
    previous_stdout = sys.stdout
    file = path.open("w", encoding="utf-8")
    try:
        sys.stdout = file
        print("Job complete")
    finally:
        sys.stdout = previous_stdout
        file.close()
    print(path.read_text(encoding="utf-8"), end="")

Job complete

Restaurar el flujo original en finally garantiza que la salida posterior vuelva a su destino anterior, incluso si falla el código del bloque redirigido. La instrucción with externa administra el directorio temporal; el archivo se cierra explícitamente después de restaurar sys.stdout.

Redirigir temporalmente la salida con contextlib.redirect_stdout()

contextlib.redirect_stdout() dirige temporalmente sys.stdout a un objeto similar a un archivo dentro de un bloque with. Al terminar el bloque, se restaura el flujo de salida estándar anterior. El archivo se sigue administrando con su propia instrucción with.

import contextlib
from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "output.txt"
    with path.open("w", encoding="utf-8") as file:
        with contextlib.redirect_stdout(file):
            print("Build finished")
    print(path.read_text(encoding="utf-8"), end="")

Build finished

Este método captura las llamadas a print() y otras escrituras en la salida estándar que se realicen dentro del contexto. No redirige la salida de error estándar (sys.stderr).

Escribir una secuencia con writelines()

writelines() escribe en el archivo, en orden, cada cadena de un iterable. No inserta saltos de línea, así que incluye \n en las cadenas si quieres que el archivo tenga líneas separadas.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "items.txt"
    lines = ["apples\n", "pears\n", "plums\n"]
    with path.open("w", encoding="utf-8") as file:
        file.writelines(lines)
    print(path.read_text(encoding="utf-8"), end="")

apples
pears
plums

Para escribir en un archivo de texto, los elementos deben ser cadenas. Si no quieres saltos de línea, omite \n de cada cadena.

Abrir y escribir archivos con pathlib

pathlib ofrece objetos para crear y manejar rutas del sistema de archivos. No sustituye a los objetos de archivo: usa Path.open() para obtener uno y luego llama a su método write(). Resulta útil cuando la ruta se compone de directorios u otros componentes.

from pathlib import Path
from tempfile import TemporaryDirectory

with TemporaryDirectory() as folder:
    path = Path(folder) / "archive" / "entry.txt"
    path.parent.mkdir()
    with path.open("w", encoding="utf-8") as file:
        file.write("Stored with pathlib.\n")
    print(path.read_text(encoding="utf-8"), end="")

Stored with pathlib.

Usa Path.write_text() para escribir texto en un solo paso cuando no necesites manejar directamente un objeto de archivo. Para escribir varias veces o usar métodos como writelines(), Path.open() te proporciona el objeto de archivo.

Para la tarea inversa, consulta cómo leer un archivo en una cadena en Python.