Cómo Conectarse a MySQL usando Python sin ORM: Guía Completa

Conectar Python a una base de datos MySQL puede parecer complicado si no usamos herramientas como ORM (Object-Relational Mapping). Sin embargo, existen métodos directos, sencillos y eficientes para lograrlo utilizando librerías estándar.

En este artículo, te enseñaré cómo conectarse a MySQL usando Python sin ORM, desde la configuración inicial hasta la ejecución de consultas SQL. Ideal para estudiantes, programadores junior y autodidactas que buscan una solución clara y funcional.

¿Por Qué Conectar Python a MySQL sin ORM?

Los ORM (como SQLAlchemy o Django ORM) simplifican el trabajo con bases de datos, pero en algunos casos es preferible una conexión directa MySQL Python porque:

• Mayor control sobre las consultas SQL.
• Mejor rendimiento en operaciones masivas.
• Aprendizaje más profundo de cómo interactúa Python con bases de datos.

Si tu objetivo es entender el funcionamiento interno o necesitas una solución ligera, esta guía es para ti.

Requisitos Previos

Antes de empezar, asegúrate de tener:

1. Python instalado (versión 3.6 o superior).
2. Servidor MySQL local o remoto.
3. MySQL Connector/Python, la librería oficial para la conexión.

Instala el conector ejecutando:

pip install mysql-connector-python

Paso 1: Establecer la Conexión con MySQL

El primer paso es crear una conexión entre Python y MySQL. Usaremos mysql.connector para esto.

Código de Conexión Básica

import mysql.connector

# Configuración de la conexión
config = {
    'user': 'tu_usuario',
    'password': 'tu_contraseña',
    'host': 'localhost',  # o la IP de tu servidor MySQL
    'database': 'nombre_base_de_datos',
    'raise_on_warnings': True
}

try:
    # Crear la conexión
    conexion = mysql.connector.connect(**config)
    print("¡Conexión exitosa a MySQL!")

    # Cerrar la conexión (importante)
    conexion.close()
except mysql.connector.Error as err:
    print(f"Error al conectar: {err}")

Explicación del Código

• user y password: Credenciales de acceso a MySQL.
• host: Dirección del servidor (localhost si es local).
• database: Nombre de la base de datos a la que te conectas.
• raise_on_warnings: Activa alertas si hay problemas.

Paso 2: Ejecutar Consultas SQL

Una vez establecida la conexión, podemos ejecutar consultas usando un cursor.

Ejemplo: Crear una Tabla

try:
    conexion = mysql.connector.connect(**config)
    cursor = conexion.cursor()

    # Consulta SQL para crear una tabla
    crear_tabla = """
    CREATE TABLE IF NOT EXISTS clientes (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(50) NOT NULL,
        email VARCHAR(50) UNIQUE
    )
    """

    cursor.execute(crear_tabla)
    print("Tabla 'clientes' creada correctamente.")

except mysql.connector.Error as err:
    print(f"Error: {err}")
finally:
    if 'conexion' in locals() and conexion.is_connected():
        cursor.close()
        conexion.close()

Ejemplo: Insertar Datos

try:
    conexion = mysql.connector.connect(**config)
    cursor = conexion.cursor()

    insertar_datos = "INSERT INTO clientes (nombre, email) VALUES (%s, %s)"
    valores = ("Juan Pérez", "juan@example.com")

    cursor.execute(insertar_datos, valores)
    conexion.commit()  # Guardar cambios
    print("Datos insertados correctamente.")

except mysql.connector.Error as err:
    print(f"Error: {err}")
finally:
    if 'conexion' in locals() and conexion.is_connected():
        cursor.close()
        conexion.close()

Paso 3: Consultar y Leer Datos

Para recuperar información, usamos fetchall(), fetchone() o fetchmany().

Ejemplo: Leer Datos

try:
    conexion = mysql.connector.connect(**config)
    cursor = conexion.cursor(dictionary=True)  # Devuelve resultados como diccionarios

    cursor.execute("SELECT * FROM clientes")
    resultados = cursor.fetchall()

    for fila in resultados:
        print(f"ID: {fila['id']}, Nombre: {fila['nombre']}, Email: {fila['email']}")

except mysql.connector.Error as err:
    print(f"Error: {err}")
finally:
    if 'conexion' in locals() and conexion.is_connected():
        cursor.close()
        conexion.close()

Problemas Comunes y Soluciones

1. Error de Conexión

• Causa: Credenciales incorrectas o servidor no disponible.
• Solución: Verifica host, user, password y que MySQL esté en ejecución.

2. No se Guardan los Cambios

• Causa: Falta conexion.commit() después de INSERT, UPDATE o DELETE.
• Solución: Siempre usa commit() para confirmar cambios.

3. Inyección SQL

• Causa: Concatenar valores directamente en consultas.
• Solución: Usa parámetros (%s) como en los ejemplos anteriores.

Buenas Prácticas

✅ Usar with para manejo automático de conexiones (Python 3+):

with mysql.connector.connect(**config) as conexion:
    with conexion.cursor() as cursor:
        cursor.execute("SELECT * FROM clientes")
        print(cursor.fetchall())

✅ Evitar credenciales hardcodeadas (usa variables de entorno).

✅ Cerrar siempre conexiones y cursores para evitar fugas de memoria.

Preguntas Frecuentes (FAQ)

1. ¿Qué diferencia hay entre mysql-connector-python y PyMySQL?

• mysql-connector-python es oficial de MySQL/Oracle.
• PyMySQL es una alternativa pura en Python.

2. ¿Puedo usar este método en producción?

Sí, pero considera usar connection pooling para mejorar el rendimiento.

3. ¿Cómo manejo transacciones?

Usa conexion.start_transaction() y conexion.rollback() si hay errores.

Conclusión

Ahora sabes cómo conectarse a MySQL usando Python sin ORM de manera eficiente. Desde la configuración inicial hasta la ejecución de consultas, este método te da control total sobre tus operaciones con bases de datos.

Si tienes dudas, déjalas en los comentarios. ¡También puedes explorar nuestro tutorial sobre conexión MySQL Python con SQLAlchemy si quieres profundizar en ORM!

¿Te resultó útil este artículo? ¡Compártelo con otros desarrolladores! 🚀