Construyendo un sistema educativo en Python (POO) conectado a MySQL — Desde cero

Crear un sistema real no es solo “conectar y ya”. Si lo haces bien desde el inicio, te queda una base sólida para escalar, mantener y hasta convertirlo en producto.

En esta publicación vamos a construir un mini sistema educativo con:

• Python + POO

• MySQL como base de datos

• Separación por capas (modelo, servicio, configuración)

Código completo: https://github.com/BrayanAngaritaR/education_project

1. ¿Qué vamos a construir?

Un sistema simple donde:

• Existen Estudiantes

• Existen Cursos

• Un estudiante puede inscribirse en cursos

2. Instalación de dependencias

Primero activa el entorno virtual ejecutando estos dos comandos:

python3 -m venv venv

source venv/bin/activate

Ahroa, instala el conector oficial de MySQL. Abre la terminal en Visual Studio Code o un editor de texto de preferencia y ejecuta:

pip install mysql-connector-python

3. Base de datos (MySQL)

Usando una herramienta con motor de base de datos como XAMPP o TablePlus vamos a ejecutar el siguiente comando.

En TablePlus simplemente presionamos en el ícono de la base de datos ⛁ y creamos la base de datos. La seleccionamos y mediante el botón SQL abrimos el editor de SQL.

Luego, pegamos el código que se encuentra debajo.

CREATE DATABASE education_system;

USE education_system;

CREATE TABLE students (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100)
);

CREATE TABLE courses (
    id INT AUTO_INCREMENT PRIMARY KEY,
    title VARCHAR(100)
);

CREATE TABLE enrollments (
    id INT AUTO_INCREMENT PRIMARY KEY,
    student_id INT,
    course_id INT,
    FOREIGN KEY (student_id) REFERENCES students(id),
    FOREIGN KEY (course_id) REFERENCES courses(id)
);

4. Estructura del proyecto

Crea los siguientes archivos en este orden

📁 education_project/
│
├── 📁 config/
│   └── 📄 database.py
│
├── 📁 models/
│   ├── 📄 student.py
│   └── 📄 course.py
│
├── 📁 services/
│   ├── 📄 student_service.py
│   └── 📄 course_service.py
│   └── 📄 enrollment_service.py
│
└── 📄 main.py

5. Conexión a MySQL (POO)

📁 config/database.py

import mysql.connector

class Database:
    def __init__(self):
        self.connection = None

    def connect(self):
        self.connection = mysql.connector.connect(
            host="localhost", #Si estás en tu computador, déjalo así
            user="root", # Usuario por defecto en la BD
            port=3306,  # Puerto por defecto
            password="123456", # Contraseña de tu BD
            database="education_system" # Nombre de tu base de datos
        )
        print("✅ Conectado a MySQL")

    def get_connection(self):
        return self.connection

    def close(self):
        if self.connection:
            self.connection.close()
            print("🔌 Conexión cerrada")

6. Modelos (POO puro)

📁 models/student.py

class Student:
    def __init__(self, id, name, email):
        self.id = id
        self.name = name
        self.email = email

📁 models/course.py

class Course:
    def __init__(self, id, title):
        self.id = id
        self.title = title

7. Servicios (lógica + base de datos)

📁 services/student_service.py

from models.student import Student

class StudentService:
    def __init__(self, db):
        self.db = db

    def create_student(self, name, email):
        conn = self.db.get_connection()
        cursor = conn.cursor()

        cursor.execute(
            "INSERT INTO students (name, email) VALUES (%s, %s)",
            (name, email)
        )
        conn.commit()
        cursor.close()

    def get_students(self):
        conn = self.db.get_connection()
        cursor = conn.cursor(dictionary=True)

        cursor.execute("SELECT * FROM students")
        rows = cursor.fetchall()

        students = []
        for row in rows:
            students.append(Student(row['id'], row['name'], row['email']))

        cursor.close()
        return students

📁 services/course_service.py

from models.course import Course

class CourseService:
    def __init__(self, db):
        self.db = db

    def create_course(self, title):
        conn = self.db.get_connection()
        cursor = conn.cursor()

        cursor.execute(
            "INSERT INTO courses (title) VALUES (%s)",
            (title,)
        )
        conn.commit()
        cursor.close()

    def get_courses(self):
        conn = self.db.get_connection()
        cursor = conn.cursor(dictionary=True)

        cursor.execute("SELECT * FROM courses")
        rows = cursor.fetchall()

        courses = []
        for row in rows:
            courses.append(Course(row['id'], row['title']))

        cursor.close()
        return courses

8. Inscripciones (relación)

Podemos crear un servicio adicional:

📁 services/enrollment_service.py

class EnrollmentService:
    def __init__(self, db):
        self.db = db

    def enroll(self, student_id, course_id):
        conn = self.db.get_connection()
        cursor = conn.cursor()

        cursor.execute(
            "INSERT INTO enrollments (student_id, course_id) VALUES (%s, %s)",
            (student_id, course_id)
        )
        conn.commit()
        cursor.close()

9. Ejecución del sistema

Ejecuta:

python main.py 

y el sistema iniciará. Si te sale error con el comando python y estás usando Mac, ejecuta en la terminal el siguiente comando para corregirlo:

alias python=python3

📁 main.py

from config.database import Database
from services.student_service import StudentService
from services.course_service import CourseService
from services.enrollment_service import EnrollmentService

db = Database()
db.connect()

student_service = StudentService(db)
course_service = CourseService(db)
enrollment_service = EnrollmentService(db)

# Crear datos
student_service.create_student("Brayan", "brayan@email.com")
course_service.create_course("POO en Python")

# Obtener datos
students = student_service.get_students()
courses = course_service.get_courses()

# Inscribir estudiante en curso
enrollment_service.enroll(students[0].id, courses[0].id)

print("🎓 Sistema funcionando correctamente")

db.close()

Al terminar la ejecución, deberías ver algo como esto:

(venv) brayanangaritar@MacBook-Pro education_project % python main.py
✅ Conectado a MySQL
🎓 Sistema funcionando correctamente
🔌 Conexión cerrada

10. ¿Qué aprendiste realmente?

Este ejemplo no es trivial. Aquí ya aplicaste:

• Programación Orientada a Objetos

• Separación por capas

• Inyección de dependencias

• Manejo básico de base de datos

• Relaciones entre entidades
  

11. Errores comunes

• Mezclar SQL dentro del main.py

• No cerrar conexiones

• No usar commit()

• Hardcodear (dejar en el código) las credenciales.