🖥️ Cómo ejecutar archivos .exe y .py desde Python sin bloquear tu programa

Un módulo práctico para automatizar tareas en Windows

Cuando trabajamos con Python en entornos Windows, tarde o temprano surge una necesidad muy común: lanzar programas externos desde nuestro script. Puede ser un instalador, una herramienta auxiliar, un script .py o cualquier .exe que forme parte de tu flujo de trabajo.

Python ofrece varias formas de hacerlo, pero una de las más flexibles y potentes es el uso del módulo subprocess. En este artículo exploramos un módulo real —EjecutaExe— que encapsula esta funcionalidad y permite ejecutar archivos en segundo plano, sin bloquear la ejecución del programa principal.

Vamos paso a paso.

🔧 ¿Qué hace exactamente este módulo?

El módulo define una clase llamada EjecutaExe, cuyo propósito es muy concreto:

Lanzar un archivo .exe o .py desde Python sin detener el flujo del programa.

Esto es especialmente útil cuando quieres:

  • Ejecutar varios archivos uno tras otro sin reiniciar tu script.
  • Lanzar procesos externos mientras tu programa sigue funcionando.
  • Automatizar tareas repetitivas desde una interfaz en consola.
  • Crear herramientas de administración o utilidades internas.

🧩 1. Entendiendo la base: subprocess

El corazón del módulo es el uso de:

import subprocess

Este módulo permite a Python comunicarse con programas externos como si los ejecutaras desde la terminal o desde el Explorador de Windows.

Pero la estrella del show es:

subprocess.Popen([...])

🚀 ¿Qué hace Popen?

  • Lanza el programa inmediatamente.
  • No espera a que termine.
  • Devuelve un objeto de proceso, que puedes consultar o controlar.

Esto significa que tu script no se queda congelado esperando a que el .exe termine. El proceso corre en paralelo, como un hilo independiente.

¿Qué puedes hacer con el objeto proceso?

Si no necesitas controlarlo, simplemente lo ignoras y listo.

🧵 2. ¿Qué significa “ejecutar en segundo plano”?

Cuando usas Popen, Python no se detiene. Continúa ejecutando el resto del código mientras el archivo externo hace su trabajo.

Si hubieras usado:

subprocess.run()

entonces sí tendrías que esperar a que el programa terminara antes de seguir.

Por eso Popen es ideal para automatización, utilidades y herramientas interactivas.

🧪 3. El ejemplo práctico del módulo

El módulo incluye un ejemplo muy didáctico: un bucle infinito que permite ejecutar varios archivos sin reiniciar el programa.

El usuario escribe la ruta del archivo, y Python lo lanza en segundo plano:

proceso = subprocess.Popen(["python", archivo])

Esto garantiza compatibilidad incluso si el sistema no tiene asociado .py con Python.

Luego:

  • Se espera 2 segundos para que el proceso arranque.
  • Se comprueba si sigue activo con poll().
  • Se muestra un mensaje claro al usuario.
  • Se usa system("pause") y system("cls") para mantener la consola limpia y ordenada.

Si el archivo no existe, se captura el error:

except FileNotFoundError:
    print("No se encontró el archivo. Si no está en el PATH, escribe la ruta completa.")

Una solución elegante y muy útil para principiantes.

🧱 4. La clase completa: modularidad y claridad

El módulo organiza la explicación y el ejemplo dentro de la clase EjecutaExe, lo que permite:

  • Reutilizar el código en otros proyectos.
  • Integrarlo en menús, GUIs o herramientas más grandes.
  • Mantener una estructura limpia y escalable.

Además, incluye cadenas de documentación (self.definicion y self.ejemplo) que explican paso a paso cómo funciona todo, lo cual es perfecto para fines educativos.

🎯 5. ¿Para qué puedo usar este módulo?

Las posibilidades son amplias:

  • Lanzar scripts auxiliares desde un menú principal.
  • Crear instaladores o lanzadores personalizados.
  • Automatizar tareas repetitivas en Windows.
  • Ejecutar herramientas externas desde una interfaz Tkinter.
  • Integrar procesos paralelos en proyectos más grandes.

Si trabajas con Python en Windows, este módulo es una pieza muy útil para tu caja de herramientas.

🧠 Conclusión

El módulo EjecutaExe demuestra cómo Python puede interactuar con el sistema operativo de forma sencilla y potente. Gracias a subprocess.Popen, puedes lanzar programas externos sin bloquear tu script, lo que abre la puerta a automatizaciones, utilidades y flujos de trabajo más profesionales.

Es un ejemplo perfecto de cómo un pequeño módulo bien diseñado puede resolver un problema real de forma elegante y didáctica.

ejecucion_exeDescarga


🎨 Cómo hacer que tu aplicación Tkinter muestre tu propio icono en la barra de tareas (Windows)

Guía completa paso a paso

🧩 1. Entender el problema: por qué Tkinter no cambia el icono de la barra de tareas

Tkinter permite cambiar:

Pero NO controla el icono de la barra de tareas.

En Windows, ese icono depende del ejecutable que está corriendo:

Qué ejecutas Icono que aparece
python.exe Icono de Python
pythonw.exe Icono de Python
Doble clic a un .py Icono asociado a Python
Un .exe creado por ti Tu icono personalizado

Por eso, aunque cambies el icono dentro de Tkinter, la barra de tareas sigue mostrando el de Python.

🚀 2. Solución real: convertir tu script en un .exe con PyInstaller

Esta es la forma profesional y definitiva.

🛠 2.1 Instalar PyInstaller

En la terminal:

pip install pyinstaller

📦 2.2 Crear el ejecutable con tu icono

Coloca tu archivo icono.ico en la misma carpeta que tu script.

Luego ejecuta:

pyinstaller --noconsole --icon=icono.ico tu_script.py

Explicación:

  • --noconsole → evita que se abra la consola negra
  • --icon=icono.ico → icono del ejecutable
  • tu_script.py → tu programa

📁 2.3 Dónde aparece tu .exe

PyInstaller crea dos carpetas:

dist/
build/

Tu ejecutable está en:

dist/tu_script/tu_script.exe

Ese .exe ya mostrará tu icono en la barra de tareas.

🎯 3. Código Tkinter correcto para iconos

Este es el código limpio y funcional:

import tkinter as tk
from PIL import Image, ImageTk

root = tk.Tk()

# Icono .ico (para Windows)
root.iconbitmap("icono.ico")

# Icono PNG (para Tkinter)
img = Image.open("icono.png")
icon = ImageTk.PhotoImage(img)
root.iconphoto(True, icon)

root.mainloop()

🧠 4. Consejos importantes para evitar errores

✔ mainloop() solo se llama una vez

Nunca lo pongas dos veces.

✔ Carga las imágenes después de crear root

Tkinter necesita un contexto activo.

✔ Usa .ico para el ejecutable

Windows no acepta PNG como icono del programa.

🎁 5. Bonus: estructura recomendada para proyectos Tkinter

mi_app/
│
├── icono.ico
├── icono.png
├── main.py
└── recursos/
    └── imágenes, sonidos, etc.

Y el comando:

pyinstaller --noconsole --icon=icono.ico main.py



Crea una ventana de Tkinter con varios botones.

🟦 ¿Qué hace este código?

Crea una ventana de Tkinter con varios botones.
Cada botón hace algo distinto: abrir una web, llamar a una clase, o cerrar la ventana.

Además, dentro de la clase MenuApp se crean todas las herramientas que usarás en tu menú (Variables, Listas, Colores, etc.).

🟦 Explicación clara del código

1. Importaciones

import tkinter as tk
import webbrowser

  • tkinter → sirve para crear ventanas y botones.
  • webbrowser → sirve para abrir páginas web.

2. Importas tus clases

from ClassMenu import Menus
from ClassVariables import Variables
...

Estas son tus clases personalizadas.
Las usarás cuando el usuario pulse un botón.

3. Creas la clase principal del menú

class MenuApp:

Esta clase contiene todo el menú.

4. Constructor __init__

def __init__(self, root):

  • root es la ventana principal.
  • Aquí configuras la ventana y creas los botones.

5. Configuración de la ventana

self.root = root
self.root.configure(bg="#1e1e1e")
self.root.title(" Programación es Python ")

  • Guardas la ventana en self.root.
  • Le pones un color de fondo.
  • Le pones un título.

6. Creas las instancias de tus clases

self.menu1 = Variables()
self.app = AppColores()
self.numerobinario = DecimalBinario()
...

Esto significa:

👉 “Voy a usar estas clases dentro del menú, así que las preparo aquí”.

7. BOTÓN 1 → Variables

boton_variables = tk.Button(
    root,
    text="VARIABLES",
    ...
    command=lambda: (
        self.menu1.variables(),
        webbrowser.open_new_tab("https://danielcaraballo.es/variables-en-python/")
    )
)
boton_variables.pack(pady=5)

¿Qué hace este botón?

  1. Llama al método variables() de tu clase Variables.
  2. Abre tu página web sobre variables.

Todo eso ocurre al pulsarlo.

8. BOTÓN 2 → f-format

boton_format = tk.Button(
    root,
    text="f- Format",
    ...
    command=lambda: webbrowser.open_new_tab("https://danielcaraballo.es/f-f-format-de-un-strings/")
)
boton_format.pack(pady=10)

Este botón solo abre una web.

9. BOTÓN 3 → Listas

boton_listas = tk.Button(
    root,
    text="Listas",
    ...
    command=lambda: webbrowser.open_new_tab("https://danielcaraballo.es/las-listas-en-python/")
)
boton_listas.pack(pady=10)

Abre tu página sobre listas.

10. BOTÓN 4 → Instalación

boton_instalacion = tk.Button(
    root,
    text="Instalación y IDE de trabajo",
    ...
    command=lambda: webbrowser.open_new_tab("https://danielcaraballo.es/lenguaje-de-programacion-python/")
)
boton_instalacion.pack(pady=10)

Abre tu página sobre instalación de Python.

11. BOTÓN 5 → Cerrar menú

boton_volver = tk.Button(
    root,
    text="Menu anterior",
    ...
    command=root.destroy
)
boton_volver.pack(pady=10)

Este botón cierra la ventana.

12. Método para iniciar el menú

@staticmethod
def iniciar_menu():
    root = tk.Tk()
    root.geometry("300x300+900+20")
    MenuApp(root)
    root.mainloop()

Esto:

  • Crea la ventana.
  • Le da tamaño y posición.
  • Crea el menú dentro de la ventana.
  • Mantiene la ventana abierta.

🟦 Resumen súper fácil

Tu código:

  • Crea una ventana.
  • Crea varios botones.
  • Cada botón abre una web o llama a una clase.
  • El último botón cierra la ventana.
  • Todo está organizado dentro de una clase llamada MenuApp.



🧭 Mini‑proyecto en Python: Menús interactivos con Programación Orientada a Objetos

En este artículo te presento un pequeño proyecto en Python que demuestra, de forma sencilla y práctica, cómo aplicar Programación Orientada a Objetos (POO) para crear un menú interactivo en consola.
El objetivo es que el usuario pueda navegar por distintas categorías del blog y abrir artículos directamente en su navegador.
Es un ejemplo ideal para aprender:

  • Cómo organizar código en clases
  • Cómo crear objetos y métodos
  • Cómo encapsular comportamientos
  • Cómo usar diccionarios para mapear opciones
  • Cómo interactuar con el sistema y el navegador
    Vamos paso a paso.

🧱 ¿Por qué este proyecto es POO?
La Programación Orientada a Objetos se basa en cuatro pilares fundamentales:

  1. Clases
  2. Objetos
  3. Métodos
  4. Encapsulación
    Este proyecto utiliza los cuatro de forma clara y didáctica.

🏗️ 1. Clases: la estructura del programa
El proyecto tiene dos clases principales:
✔
Es la clase encargada de mostrar todos los menús y ejecutar las acciones correspondientes.
Dentro de ella viven métodos como:

  • Cada método representa una pantalla o acción del programa.
    ✔
    Es la clase que contiene el punto de entrada del programa.
    Su método es el encargado de:
  • Crear un objeto
  • Mostrar el menú principal
  • Leer la opción del usuario
  • Llamar al menú correspondiente

🧩 2. Objetos: instancias que ejecutan acciones
En se crea un objeto:

Ese objeto es el que:

  • Muestra los menús
  • Abre enlaces
  • Gestiona la interacción
    En POO, un objeto es una instancia de una clase, y este proyecto lo utiliza exactamente como debe ser.

🛠️ 3. Métodos: comportamientos del objeto
Cada menú es un método dentro de la clase .
Por ejemplo:

  • abre artículos según el lenguaje elegido
  • abre la categoría de cocina
  • abre la sección de historia
    En POO, los métodos representan acciones que un objeto puede realizar.
    Aquí se ve de forma muy clara.

🔒 4. Encapsulación: organización y claridad
Aunque este proyecto no usa atributos privados, sí encapsula comportamientos dentro de clases.
Esto significa:

  • El código está organizado
  • Cada clase tiene una responsabilidad clara
  • No hay funciones sueltas
  • Todo está agrupado de forma lógica
    Es exactamente lo que busca la POO:
    👉 orden, modularidad y claridad.

📁 Estructura del proyecto

🧠 ¿Qué hace cada archivo?
📌
Contiene la clase , que agrupa todos los menús y acciones.
Es el “cerebro visual” del programa.

  • Muestra el menú principal
  • Permite elegir lenguajes de programación
  • Abre categorías del blog
  • Usa diccionarios para mapear opciones
  • Usa para abrir enlaces
  • Usa para no bloquear la ejecución

📌
Contiene la clase y el método .

  • Crea un objeto
  • Muestra el menú principal
  • Lee la opción del usuario
  • Valida la entrada
  • Llama al menú correspondiente
  • Abre el blog al salir
    Además, utiliza para indicar que no necesita una instancia de la clase.

🎯 Conclusión
Este proyecto es un ejemplo perfecto de Programación Orientada a Objetos aplicada a un caso real:

  • Las clases organizan el código
  • Los objetos ejecutan acciones
  • Los métodos representan comportamientos
  • La encapsulación mantiene todo limpio y modular
    Es sencillo, práctico y útil, ideal para quienes están aprendiendo Python y quieren ver cómo se aplica la POO en un proyecto real.

ArchivosPoo_PythonDescarga

📝 Nota final del artículo

Crea todo el proyecto dentro de la misma carpeta.
Si colocas los archivos en directorios distintos o cambias su ubicación sin ajustar las rutas, el proyecto no funcionará correctamente.



🧾 Cómo crear un Registro de Personal en Python con JSON (guía didáctica y visual)

La estructura está pensada para que el lector aprenda, disfrute y pueda copiar el código sin miedo.
Aquí la tienes 👇

🧾 Cómo crear un Registro de Personal en Python con JSON (guía didáctica y visual)
En este artículo vamos a construir un pequeño sistema para registrar personas, guardar sus datos en un archivo JSON y buscar empleados por cargo.
Todo desde consola, paso a paso, con código limpio y explicaciones claras.
Ideal para quienes están aprendiendo Python y quieren practicar clases, archivos, JSON y bucles.

🎯 Objetivo del proyecto
Vamos a crear un programa que permita:

  • Registrar personas (nombre, edad, sexo, cargo).
  • Guardarlas en un archivo sin borrar lo anterior.
  • Mostrar los datos guardados.
  • Buscar personas por cargo.
  • Mantener un formato bonito y legible.

🧱 1. La clase
Comenzamos creando una clase que represente a cada persona:

Esta clase nos permite trabajar con objetos, pero también convertirlos a diccionarios para guardarlos en JSON.

📦 2. Guardar datos en un archivo JSON
Creamos una función que:

  1. Carga el archivo si existe.
  2. Si no existe, crea una lista vacía.
  3. Agrega la nueva persona.
  4. Guarda todo con formato bonito.

📝 3. Registrar una persona
Pedimos los datos por consola, creamos el objeto y lo guardamos:

🔍 4. Buscar personas por cargo
Ahora viene la parte interactiva: un pequeño menú para buscar empleados por cargo.

📁 5. ¿Cómo queda el archivo ?
Después de registrar varias personas, el archivo se verá así:

Cada nueva persona se agrega al final sin borrar lo anterior.

🎨 6. Explicación visual (tu toque didáctico)
Imagina el archivo JSON como una estantería de fichas:

Cada vez que registras una persona, simplemente añades una ficha más.
Y cuando buscas por cargo, el programa revisa cada ficha como si dijera:

Hasta encontrar coincidencias.

🧠 7. Qué aprende el lector con este proyecto

  • Uso de clases en Python.
  • Conversión de objetos a diccionarios.
  • Lectura y escritura de archivos JSON.
  • Manejo de errores.
  • Búsquedas dentro de listas.
  • Interacción por consola.
  • Persistencia de datos.
    Un proyecto perfecto para principiantes que quieren dar un salto hacia programas más útiles y reales.

FichaPersonalPythonDescarga

1. Importaciones

import json

import os from os

import system

¿Qué hace cada una?

  • json → permite leer y escribir archivos JSON.
  • os → permite comprobar si un archivo existe.
  • system → permite ejecutar comandos del sistema como pause o cls.

🧱 2. Clase Personal

class Personal: def __init__(self, nombre, edad, sexo, cargo): self.nombre = nombre self.edad = edad self.sexo = sexo self.cargo = cargo

¿Qué es esto?

Es un molde para crear personas.
Cada persona tendrá:

  • nombre
  • edad
  • sexo
  • cargo

📌 Método para mostrar información

def mostrar_informacion(self):

print(f»Nombre: {self.nombre}»)

print(f»Edad: {self.edad}»)

print(f»Sexo: {self.sexo}»)

print(f»Cargo: {self.cargo}»)

Muestra los datos en pantalla de forma ordenada.

📌 Método para convertir a diccionario

def convertir_a_diccionario(self):

return { «nombre»: self.nombre, «edad»: self.edad, «sexo»: self.sexo, «cargo»: self.cargo }

Esto es necesario porque JSON no puede guardar objetos, pero sí diccionarios.

📦 3. Función para guardar en JSON

def guardar_en_json(persona_dict):

archivo = «personal.json»

if os.path.exists(archivo):

with open(archivo, «r», encoding=»utf-8″) as f: datos = json.load(f)

else: datos = [] datos.append(persona_dict)

with open(archivo, «w», encoding=»utf-8″) as f: json.dump(datos, f, indent=4, ensure_ascii=False)

¿Qué hace?

  1. Comprueba si el archivo existe

    • Si existe → lo abre y carga su contenido.
    • Si no existe → crea una lista vacía.

  2. Agrega la nueva persona a la lista.
  3. Vuelve a guardar todo en el archivo JSON.

¿Por qué funciona tan bien?

Porque no borra lo anterior, solo añade.

🧑‍💻 4. Programa principal: registrar una persona

print(«—–Registro de Personal—–\n»)

nombre = input(«Ingrese el nombre: «)

edad = input(«Ingrese la edad: «)

sexo = input(«Ingrese el sexo: «)

cargo = input(«Ingrese el cargo: «)

Pide los datos al usuario.

📌 Crear el objeto

persona = Personal(nombre, edad, sexo, cargo)

Aquí se crea una persona real usando la clase.

📌 Mostrar y guardar

persona.mostrar_informacion() guardar_en_json(persona.convertir_a_diccionario())

  • Muestra los datos en pantalla.
  • Convierte la persona a diccionario.
  • La guarda en el archivo JSON.

📁 5. Leer el archivo JSON

with open(«personal.json», «r», encoding=»utf-8″) as archivo: datos = json.load(archivo)

Carga todas las personas registradas en una lista llamada datos.

🔍 6. Búsqueda por cargo

while True: print(«\n Estas en buscar a una persona por cargo \n»)

cargo_buscar = input(«Ingrese el cargo a buscar (o ‘salir’ para terminar): «) 

Bucle infinito hasta que el usuario escriba salir.

📌 Buscar coincidencias

encontrado = False for persona in datos:

if persona[«cargo»].lower() == cargo_buscar.lower():

print(«Persona encontrada:»)

print(json.dumps(persona, indent=4, ensure_ascii=False)) encontrado = True break

¿Qué hace?

  • Recorre todas las personas del JSON.
  • Compara el cargo ignorando mayúsculas/minúsculas.
  • Si encuentra una coincidencia:

  • La imprime en formato bonito.
  • Marca encontrado = True.
  • Sale del bucle.

📌 Si no encuentra nada

if not encontrado: print(«Cargo no encontrada.»)

📌 Pausa y limpiar pantalla

system(«pause»)

system(«cls»)

  • pause → espera que el usuario presione una tecla.
  • cls → limpia la pantalla (solo Windows).

🎯 Resumen visual del flujo

[Usuario escribe datos]

↓ [Se crea un objeto Personal]

↓ [Se convierte a diccionario]

↓ [Se guarda en personal.json]

↓ [Se cargan todos los registros]

↓ [Usuario busca por cargo]

↓ [Se muestran coincidencias]



Poo en Python muy sencillo

Código completo (para referencia)

class Animal:
    def __init__(self, nombre):
        self.nombre = nombre

    def hablar(self):
        return "Sonido genérico"
class Perro(Animal):
    def hablar(self):
        return "Guau!"
class Gato(Animal):
    def hablar(self):
        return "Miau!"
animales = [Perro("Firulais"), Gato("Misu")]

for animal in animales:
    print(f"{animal.nombre} dice: {animal.hablar()}")

Primera parte: clase Animal

class Animal:

  • class Animal:
    Declara una nueva clase llamada Animal.
    Una clase es un “molde” o “plantilla” para crear objetos del tipo Animal.

    def __init__(self, nombre):

  • def __init__(self, nombre):
    Define el método especial __init__, que es el constructor.
    Se ejecuta automáticamente cuando creas un Animal.

    • self representa al propio objeto.
    • nombre es un parámetro que recibirá el nombre del animal.

        self.nombre = nombre

  • self.nombre = nombre
    Crea un atributo llamado nombre dentro del objeto.
    Guarda en self.nombre el valor que se pasa al crear el animal.
    Es decir, el objeto recordará su nombre.

    def hablar(self):

  • def hablar(self):
    Declara un método llamado hablar para la clase Animal.
    Este será el comportamiento “genérico” de hablar.

        return "Sonido genérico"

  • return "Sonido genérico"
    Cuando se llame a hablar() en un Animal, devolverá esta cadena.
    Más adelante, las clases hijas lo cambiarán por sonidos más específicos.

Segunda parte: clase Perro que hereda de Animal

class Perro(Animal):

  • class Perro(Animal):
    Crea una clase Perro que hereda de Animal.
    Eso significa que Perro tiene todo lo de Animal (como nombre), pero puede añadir o cambiar cosas.

    def hablar(self):

  • def hablar(self):
    Define el método hablar en Perro.
    Este método sobrescribe (reemplaza) el hablar genérico de Animal.

        return "Guau!"

  • return "Guau!"
    Cuando se llame a hablar() en un Perro, devolverá "Guau!".

Tercera parte: clase Gato que también hereda de Animal

class Gato(Animal):

  • class Gato(Animal):
    Declara la clase Gato que también hereda de Animal.
    Igual que Perro, tiene nombre y puede hablar.

    def hablar(self):

  • def hablar(self):
    Sobrescribe el método hablar para los gatos.

        return "Miau!"

  • return "Miau!"
    Cuando se llame a hablar() en un Gato, devolverá "Miau!".

Cuarta parte: creando objetos y usando polimorfismo

animales = [Perro("Firulais"), Gato("Misu")]

  • animales = [...]
    Crea una lista llamada animales.
  • Perro("Firulais")
    Crea un objeto de tipo Perro con nombre = "Firulais".
    Internamente llama a __init__ de Animal y guarda ese nombre.
  • Gato("Misu")
    Crea un objeto de tipo Gato con nombre = "Misu".
    También usa el constructor heredado.
  • La lista contiene ahora dos objetos: un perro y un gato.

for animal in animales:

  • for animal in animales:
    Inicia un bucle que recorre cada elemento de la lista animales.
    En cada vuelta, la variable animal será:

    • Primero, el Perro("Firulais")
    • Después, el Gato("Misu")

    print(f"{animal.nombre} dice: {animal.hablar()}")

  • print(f"{animal.nombre} dice: {animal.hablar()}")
    Usa una f-string para formatear el texto.

  • Aquí es donde aparece el polimorfismo:

    • Si animal es un Perro, hablar() devuelve "Guau!".
    • Si animal es un Gato, hablar() devuelve "Miau!".

  • En pantalla verás:

    • Firulais dice: Guau!
    • Misu dice: Miau!



Envío de correos desde Python

¿Qué es MIME?

MIME (Extensiones Multipropósito de Correo de Internet) es un estándar que permite la transmisión de varios tipos de contenido a través del correo electrónico, más allá del texto simple.

  • Versatilidad: MIME permite incluir texto, imágenes, audio, video y otros tipos de archivos en los mensajes de correo electrónico.
  • Codificación: Especifica métodos para codificar datos no textuales en texto plano para una transmisión segura por Internet.
  • Encabezados: Agrega campos adicionales a los encabezados estándar del correo electrónico para indicar el tipo y la codificación del contenido.

Ejemplo de Código, vemos que es una clase:

import smtplib
import mimetypes
from email.message import EmailMessage
from email.utils import make_msgid
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders

Configuración del servidor SMTP

smtp_server = «smtp.gmail.com»
smtp_port = 587
username = «tu_correo@gmail.com»
password = «tu_contraseña»

Creación del mensaje

msg = MIMEMultipart()
msg[‘From’] = username
msg[‘To’] = «destinatario@ejemplo.com»
msg[‘Subject’] = «Asunto del Correo»

Cuerpo del correo

body = «Hola, este es un correo con un archivo adjunto.»
msg.attach(MIMEText(body, ‘plain’))

Adjuntar archivo

filename = «archivo.txt»
attachment = open(filename, «rb»)

mime_base = MIMEBase(‘application’, ‘octet-stream’)
mime_base.set_payload(attachment.read())
encoders.encode_base64(mime_base)
mime_base.add_header(‘Content-Disposition’, f»attachment; filename= {filename}»)

msg.attach(mime_base)

Envío del correo

server = smtplib.SMTP(smtp_server, smtp_port)
server.starttls()
server.login(username, password)
server.send_message(msg)
server.quit()

print(«Correo enviado con éxito.»)

Este código hace lo siguiente:

  1. Configura el servidor SMTP.
  2. Crea un mensaje MIME multipart.
  3. Adjunta un cuerpo de texto al correo.
  4. Adjunta un archivo.
  5. Envía el correo a través del servidor SMTP

De no existir el archivo nos remitirá este error:

attachment = open(filename, «rb»)
FileNotFoundError: [Errno 2] No such file or directory: ‘archivo.txt’



Cargar una imagen desde un archivo en Python.

Para cargar una imagen desde un script en Python, debemos hacer uso de biblioteca PIL. De lo contrario, lanzará el error: ‘ModuleNotFoundError: No module named ‘PIL’.

la biblioteca de imágenes de Python (PIL). Este error generalmente ocurre cuando el módulo PIL no está instalado en tu entorno de Python. Para resolver esto, puedes instalar la biblioteca Pillow, que es la versión actualizada y más compatible de PIL. Aquí te explico cómo hacerlo:

  1. Abre tu terminal o símbolo del sistema
  2. Ejecuta el siguiente comando:

  • Tambien es muy posible que nos falle otra vez y ahora con este mensaje al intentar instalar pillow.

mas o menos asi:

Este mensaje de error indica que el comando pip no se reconoce en tu sistema porque no está configurado correctamente en tu variable de entorno PATH. Aquí te dejo los pasos para solucionarlo:

Para reproducir o mostrar una imagen en Python, puedes usar la biblioteca Pillow, que ya mencionamos anteriormente es posible que hasta que no reinicies el P.C. siga dando error.

Aquí tienes un ejemplo simple de cómo hacerlo:

  1. Primero, asegúrate de tener Pillow instalado:
  2. Luego, usa el siguiente código para abrir y mostrar una imagen:

Este código abrirá la imagen especificada por la ruta y la mostrará en una ventana. Solo tienes que reemplazar 'ruta/a/tu/imagen.jpg' con la ruta de la imagen que deseas mostrar.

En este ejemplo de código fuente, he seleccionado una foto del blog de un café, y ambos archivos están en la misma carpeta, por lo que deberían abrirse de esta manera:



Modulo time en python

Con la ayuda de Microsoft Copilot, su compañero de IA, se ha creado este artículo.

– Módulo time en Python proporciona varias funciones para trabajar con el tiempo y la fecha. A continuación, se describen algunas de las funciones más comunes que ofrece:

  • time.time(): Devuelve el tiempo actual en segundos desde la época (1 de enero de 1970), que fue cuando los que crearon este módulo así lo decidieron el inicio.
  • time.sleep(secs): Pausa la ejecución del programa durante el número de segundos especificado.
  • time.localtime([secs]): Convierte un número de segundos desde la época en una estructura de tiempo local. Si no se especifican los segundos, utiliza el tiempo actual.
  • time.strftime(format, t): Convierte una tupla de tiempo o una estructura de tiempo en una cadena de caracteres según el formato especificado.
  • time.strptime(string, format): Convierte una cadena de caracteres en una estructura de tiempo según el formato especificado.

Ejemplo de uso:

Más ejemplos de cómo funcionan estas funciones:



Base de datos SQLite3 y DB browser

El módulo que viene preinstalado en Python para trabajar con bases de datos es SQLite, y se importa de la siguiente manera:

  • import sqlite3

Este módulo facilita la conexión a SQLite mediante el método ‘connect’, al cual debemos especificar la ruta del archivo; si el archivo no existe, se creará automáticamente.

Para evitar que no de un error devemos de poner un condicional para que no cree la tabla si ya existe, con un if mas o menos de esta forma:

  • CREATE TABLE if not exists nombre de la tabla

Debemos cerrar con close() porque si no lo hacemos, no podremos trabajar con ella.

Ejemplo de codigo:

Podemos crear el codigo de SQlite desde la aplicacion que ya te trae desde su WEB o bien copia y pegar.

Lo instalamos desde la página web httpswww.sqlite.org y luego procedemos a la instalación.

DB Browser for SQLite es el editor que nos permite interactuar con las bases de datos.

DB Browser for SQLite pagina de descarga:

Forma de introducir datos en una base:

  • cursor.executemany(«INSERT INTO personal VALUES(?,?,?)», nombre de la tabla)