[Listo para Copiar y Pegar] ¡Crea una Sencilla App de Bloc de Notas con Python! Con Guardado de Archivos

«¡Quiero intentar construir algo tangible con programación!»

Si ese eres tú, has venido al lugar correcto. En este artículo, te explicaré de la manera más sencilla posible cómo crear tu propia y simple «app de bloc de notas» donde puedes escribir texto y guardarlo en un archivo usando el lenguaje de programación Python.

¡Hola! Soy un desarrollador web autodidacta que, con la ayuda de la IA, empecé desde cero en programación hace solo unos meses. Al principio, estaba en un nivel en el que pensaba: «¿Guardar archivos? ¿Es algún tipo de hechizo mágico?» (jaja). Es precisamente por eso que quiero evitar la jerga tanto como sea posible y guiarte a través de esto, compartiendo los puntos en los que tropecé como compañero principiante.

El objetivo de este artículo es simple: dejarte experimentar la emoción de «¡mi propio programa está funcionando!». Para ello, ¡dejaremos las cosas difíciles para más tarde! Primero, ¡copiemos, peguemos y juguemos con el producto terminado!

PASO 1: ¡Ejecutémoslo de inmediato! Aquí está el código completo

Ver para creer. Primero, copia todo el código a continuación, guárdalo como memo_app.py e intenta ejecutarlo. Si no tienes un entorno de Python configurado, por favor, prepáralo primero.

Si estás pensando, «¿Espera, ya el código final?» o «¿Dónde está la explicación?», ¡estás en el camino correcto! Experimentar ese momento de «¡funciona!» primero es el secreto para que la programación sea divertida.

import tkinter as tk
import tkinter.filedialog as filedialog

def save_file():
    """Función para guardar un archivo"""
    file_path = filedialog.asksaveasfilename(
        defaultextension=".txt",
        filetypes=[("Archivos de texto", "*.txt"), ("Todos los archivos", "*.*")]
    )
    if not file_path:
        return
    try:
        with open(file_path, 'w', encoding='utf-8') as file:
            text_content = text_area.get(1.0, tk.END)
            file.write(text_content)
    except Exception as e:
        print(f"Ocurrió un error: {e}")

def open_file():
    """Función para abrir un archivo"""
    file_path = filedialog.askopenfilename(
        filetypes=[("Archivos de texto", "*.txt"), ("Todos los archivos", "*.*")]
    )
    if not file_path:
        return
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            text_content = file.read()
            text_area.delete(1.0, tk.END)
            text_area.insert(tk.END, text_content)
    except Exception as e:
        print(f"Ocurrió un error: {e}")

# Crear la ventana principal
window = tk.Tk()
window.title("Bloc de notas simple")
window.geometry("600x400")

# Crear el área de entrada de texto
text_area = tk.Text(window, wrap=tk.WORD)
text_area.pack(expand=True, fill=tk.BOTH)

# Crear la barra de menú
menu_bar = tk.Menu(window)
window.config(menu=menu_bar)

# Crear el menú "Archivo"
file_menu = tk.Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Archivo", menu=file_menu)
file_menu.add_command(label="Abrir...", command=open_file)
file_menu.add_command(label="Guardar como...", command=save_file)
file_menu.add_separator()
file_menu.add_command(label="Salir", command=window.quit)

# Mostrar la ventana
window.mainloop()
    

¿Qué tal te fue? Si ves una ventana como esta, ¡es un gran éxito!

Intenta escribir algo de texto o seleccionar «Guardar como...» o «Abrir...» en el menú. ¿No es un poco emocionante que realmente funcione como un bloc de notas?

PASO 2: ¡Explorando el código! Echemos un vistazo a cómo funciona

Ahora que has experimentado el momento de «¡funciona!», exploremos «¿por qué funciona?». Desglosaremos el código de antes en partes y explicaremos el papel de cada una.

① Preparando la caja de herramientas mágica (import)

Las dos primeras líneas del código son como un hechizo mágico para cargar las «herramientas útiles» que vamos a usar en Python.

import tkinter as tk
import tkinter.filedialog as filedialog
    

• `tkinter`: Es una biblioteca estándar de Python para crear fácilmente GUIs (Interfaces Gráficas de Usuario) como ventanas y botones. Por así decirlo, es la caja de herramientas para crear el esqueleto y las piezas de tu aplicación.
• `tkinter.filedialog`: Es una herramienta especializada para mostrar cuadros de diálogo familiares como «Abrir archivo» y «Guardar como».

② Construyendo los cimientos de la app (Creación de la ventana)

A continuación, creamos la ventana principal para nuestra aplicación. En términos de construcción de una casa, esto es como los cimientos y la estructura.

# Crear la ventana principal
window = tk.Tk()
window.title("Bloc de notas simple")
window.geometry("600x400")

# ... (código omitido) ...

# Mostrar la ventana
window.mainloop()
    

• `window = tk.Tk()`: Este es el comando que crea la ventana en sí. Significa: «Usando el plano `Tk()` de la caja de herramientas `tk`, crea una ventana llamada `window`».
• `window.title(...)`: Esto establece el texto que aparece en la barra de título de la ventana.
• `window.geometry("600x400")`: Esto establece el tamaño inicial de la ventana en «600 píxeles de ancho por 400 píxeles de alto».
• `window.mainloop()`: ¡Esta es la parte más importante! Es el comando que muestra la ventana creada y la mantiene en ejecución hasta que el usuario la cierre. Sin esto, el programa se iniciaría y terminaría en un instante, y nunca llegarías a ver la ventana.

③ Preparando un lugar para escribir (Área de texto)

Es un bloc de notas, así que, por supuesto, necesitamos un espacio para escribir texto. Esta es la parte que lo crea.

# Crear el área de entrada de texto
text_area = tk.Text(window, wrap=tk.WORD)
text_area.pack(expand=True, fill=tk.BOTH)
    

• `text_area = tk.Text(...)`: Usamos un componente (llamado widget) llamado `Text` de la caja de herramientas `tk` para crear el área de entrada de texto. `wrap=tk.WORD` es una configuración que ajusta las líneas en los límites de las palabras, un buen detalle para evitar saltos extraños en medio de las palabras.
• `text_area.pack(...)`: Este comando coloca el `text_area` creado en su padre, la `window`. `pack` es un método de diseño simple, y al especificar `expand=True, fill=tk.BOTH`, obtienes un diseño inteligente donde «si el tamaño de la ventana cambia, el área de texto también se expandirá para llenarla arriba, abajo, a la izquierda y a la derecha».

④ Creando cajas de comandos (Funciones)

Finalmente, llegamos al corazón de esta aplicación: los procesos específicos para «Abrir archivo» y «Guardar archivo». Estos procesos se definen como funciones, que son como «cajas útiles que agrupan comandos».

Guardando un archivo: La función `save_file()`

def save_file():
    """Función para guardar un archivo"""
    file_path = filedialog.asksaveasfilename(
        defaultextension=".txt",
        filetypes=[("Archivos de texto", "*.txt"), ("Todos los archivos", "*.*")]
    )
    if not file_path:
        return
    try:
        with open(file_path, 'w', encoding='utf-8') as file:
            text_content = text_area.get(1.0, tk.END)
            file.write(text_content)
    except Exception as e:
        print(f"Ocurrió un error: {e}")
    

Este código está lleno de puntos importantes.

1. `filedialog.asksaveasfilename(...)`: Este es el comando que muestra el cuadro de diálogo «Guardar como». La ruta de la ubicación de guardado elegida por el usuario (como una dirección que lleva al nombre del archivo) se almacena en una variable llamada `file_path`.
2. `if not file_path: return`: Si el usuario hace clic en «Cancelar» en el diálogo, `file_path` estará vacío. Esta es una línea crucial que simplemente sale de la función sin hacer nada en ese caso.
3. `with open(file_path, 'w', encoding='utf-8') as file:`: ¡Esta es la clave para la E/S de archivos!
   • `open()`: Un comando para abrir el archivo en la ruta especificada en el modo especificado.
   • `'w'`: Significa modo `write` (escritura). Si el archivo no existe, se crea. Si existe, se sobrescribe.
   • `encoding='utf-8'`: Un hechizo mágico súper importante para evitar texto corrupto. Especifica «UTF-8», una codificación de caracteres estándar que puede manejar correctamente la mayoría de los idiomas del mundo. Sin esto, los caracteres que no sean en inglés podrían no guardarse correctamente.
   • `with ... as file:`: Usar esta sintaxis asegura que el archivo se cierre automáticamente después de que el bloque de código termine. Olvidar cerrar un archivo puede causar problemas como fugas de memoria, por lo que esta es una forma de escribir código muy segura y recomendada. (También recomendado en la documentación oficial)
4. `text_area.get(1.0, tk.END)`: Esto obtiene todo el texto que se encuentra actualmente en el área de texto.
5. `file.write(text_content)`: Esto escribe el texto recuperado en el archivo abierto.

Del mismo modo, la función `open_file()` simplemente usa `'r'` (modo de lectura) para leer el contenido de un archivo y mostrarlo en el área de texto. ¡El mecanismo es casi idéntico!

PASO 3: ¡Edición avanzada! Personalicemos tu bloc de notas

Ahora que entiendes la mecánica básica, ¡hagámoslo más interesante! Puedes implementar funciones útiles simplemente agregando un poco de código.

Personalización 1: Crear un diseño estilo modo oscuro

El modo oscuro está de moda en estos días. Cambiemos el diseño para que sea más agradable a la vista. Solo necesitas especificar los colores de fondo y primer plano donde creas la `window` y el `text_area`.

# Crear la ventana principal
window = tk.Tk()
window.title("Bloc de notas oscuro")
window.geometry("600x400")
window.config(bg="#2d2d2d") # Añadir el color de fondo de la ventana

# Crear el área de entrada de texto
text_area = tk.Text(
    window, 
    wrap=tk.WORD,
    bg="#1e1e1e",          # Color de fondo del área de texto
    fg="#dcdcdc",          # Color del texto
    insertbackground="#ffffff" # Color del cursor
)
text_area.pack(expand=True, fill=tk.BOTH)
    

Solo con esto, tiene un aspecto mucho más moderno, ¿verdad?

Personalización 2: Añadir atajos de teclado

Abrir el menú cada vez es una molestia, ¿verdad? Hagamos que puedas guardar con «Ctrl + S» y abrir con «Ctrl + O». Al agregar elementos al menú, especificaremos el atajo con `accelerator` y luego usaremos `window.bind` para conectar la pulsación de tecla real a la función.

Primero, cambia la parte de creación del menú así:

# Crear el menú "Archivo"
file_menu = tk.Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Archivo", menu=file_menu)
# Usar accelerator para mostrar una pista para el atajo
file_menu.add_command(label="Abrir...", command=open_file, accelerator="Ctrl+O")
file_menu.add_command(label="Guardar como...", command=save_file, accelerator="Ctrl+S")
file_menu.add_separator()
file_menu.add_command(label="Salir", command=window.quit)
    

A continuación, agrega el código para vincular las pulsaciones de teclas a las funciones justo antes de `window.mainloop()`.

# Vincular atajos de teclado
# Usar lambda para manejar el argumento del evento
window.bind("<Control-s>", lambda event: save_file())
window.bind("<Control-o>", lambda event: open_file())

# Mostrar la ventana
window.mainloop()
    

El método `bind` llama a una función cuando ocurre un evento (en este caso, una pulsación de tecla), y cuando lo hace, pasa información sobre el evento (el objeto `event`) como argumento. Sin embargo, nuestras funciones `save_file` y `open_file` no están diseñadas para aceptar argumentos. Por lo tanto, al usar `lambda event:`, estamos creando un intermediario que ignora el argumento y llama a nuestra función deseada. ¡Es un pequeño truco ingenioso!

Cosas a tener en cuenta (Una advertencia)

Las operaciones con archivos son una fuente común de errores inesperados. Yo también me quedé mirando pantallas de error y me llevé las manos a la cabeza muchas veces al principio... Solo saber sobre los errores comunes puede ayudarte a evitar el pánico.

• `PermissionError`: Esto ocurre si intentas guardar en una carpeta protegida contra escritura (p. ej., `C:\Program Files`). Elige una ubicación donde tengas permisos de escritura, como tu Escritorio o la carpeta Documentos.
• `FileNotFoundError`: Esto sucede en la función `open_file` si especificas un archivo que no existe. Dado que nuestro código utiliza `filedialog`, esto generalmente no sucederá, pero es algo a tener en cuenta si modificas el código.
• `UnicodeDecodeError`: Esto ocurre si intentas abrir un archivo que no se puede leer con `encoding='utf-8'` (p. ej., un archivo de texto antiguo guardado con `Shift_JIS`). Este es un problema muy profundo, pero por ahora, es suficiente saber que «existen muchas codificaciones de caracteres diferentes en el mundo».

En nuestro código, usamos un bloque `try...except` para capturar errores, por lo que incluso si ocurre un error, la aplicación no se bloqueará y se mostrará un mensaje de error en la consola. Esta es otra técnica importante para construir programas robustos.

Conclusión: Un pequeño éxito es un gran paso adelante

¡Buen trabajo! En este artículo, usamos `Tkinter` de Python para crear una aplicación de bloc de notas simple con una función de guardado de archivos.

¿Pudiste experimentar comenzando desde copiar y pegar, entendiendo el mecanismo y finalmente personalizándolo tú mismo? La experiencia de «ver que el código que escribí funciona de manera visible» es una alegría como ninguna otra y es la mejor motivación para seguir aprendiendo a programar.

La aplicación que construimos hoy es solo el comienzo. Puedes agregar innumerables funciones dependiendo de tus ideas, como una función de búsqueda, conteo de palabras o guardado automático. ¡Por favor, usa este artículo como base e intenta desarrollar tu propia aplicación original!

Extra: El código Python completo y listo para ejecutar

Aquí está el código Python final y completo que incorpora todos los ejemplos discutidos en este artículo, incluido el diseño de estilo de modo oscuro y los atajos de teclado. ¡Solo copia y pega esto, y tendrás una aplicación de bloc de notas rica en funciones lista para usar al instante!

<?php
/*
Este es un script de Python, no un archivo PHP para ser ejecutado en un servidor web.
Por favor, cambia la extensión a .py y ejecútalo con un intérprete de Python.
Ejemplo: python tu_nombre_de_archivo.py
*/
?>
import tkinter as tk
import tkinter.filedialog as filedialog

def save_file():
    """Función para guardar el archivo"""
    file_path = filedialog.asksaveasfilename(
        defaultextension=".txt",
        filetypes=[("Archivos de texto", "*.txt"), ("Todos los archivos", "*.*")]
    )
    if not file_path:
        return
    try:
        with open(file_path, 'w', encoding='utf-8') as file:
            text_content = text_area.get(1.0, tk.END)
            file.write(text_content)
    except Exception as e:
        # Idealmente, esto se registraría o se notificaría al usuario con un diálogo
        print(f"Ocurrió un error: {e}")
        window.title(f"Error: {e}")


def open_file():
    """Función para abrir un archivo"""
    file_path = filedialog.askopenfilename(
        filetypes=[("Archivos de texto", "*.txt"), ("Todos los archivos", "*.*")]
    )
    if not file_path:
        return
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            text_content = file.read()
            text_area.delete(1.0, tk.END)
            text_area.insert(tk.END, text_content)
            window.title(f"Bloc de notas - {file_path}")
    except Exception as e:
        print(f"Ocurrió un error: {e}")
        window.title(f"Error: {e}")


# --- Configuración de la GUI ---

# Crear la ventana principal
window = tk.Tk()
window.title("Bloc de notas mejorado")
window.geometry("800x600")
window.config(bg="#2d2d2d") # Color de fondo de la ventana

# Crear el área de entrada de texto
text_area = tk.Text(
    window,
    wrap=tk.WORD,
    bg="#1e1e1e",          # Color de fondo del área de texto
    fg="#dcdcdc",          # Color del texto
    insertbackground="#ffffff", # Color del cursor (blanco para mayor visibilidad)
    undo=True,             # Habilitar la función Deshacer/Rehacer
    autoseparators=True
)
text_area.pack(expand=True, fill=tk.BOTH, padx=5, pady=5)


# Crear la barra de menú
menu_bar = tk.Menu(window)
window.config(menu=menu_bar)

# Crear el menú "Archivo"
file_menu = tk.Menu(menu_bar, tearoff=0, bg="#2d2d2d", fg="#dcdcdc")
menu_bar.add_cascade(label="Archivo", menu=file_menu)
file_menu.add_command(label="Abrir...", command=open_file, accelerator="Ctrl+O")
file_menu.add_command(label="Guardar como...", command=save_file, accelerator="Ctrl+S")
file_menu.add_separator()
file_menu.add_command(label="Salir", command=window.quit)

# Vincular atajos de teclado (usando lambda para ignorar el argumento del evento)
window.bind("<Control-s>", lambda event: save_file())
window.bind("<Control-o>", lambda event: open_file())
window.bind("<Control-S>", lambda event: save_file()) # También maneja la pulsación simultánea de la tecla Shift
window.bind("<Control-O>", lambda event: open_file()) # También maneja la pulsación simultánea de la tecla Shift

# Iniciar el bucle de eventos principal de la ventana
window.mainloop()