Можно ли в Python использовать MySQL?

Использование MySQL с Python

Да, абсолютно можно! Python отлично работает с MySQL. Существует несколько популярных способов подключения и работы с этой базой данных.

Основные драйверы MySQL для Python

1. PyMySQL (чистый Python)

import pymysql

# Установка: pip install pymysql

# Подключение
connection = pymysql.connect(
    host='localhost',
    user='root',
    password='password',
    database='mydb',
    port=3306
)

# Создание курсора
cursor = connection.cursor()

# SQL запрос
sql = "SELECT * FROM users WHERE id = %s"
cursor.execute(sql, (1,))

# Получение результата
result = cursor.fetchone()  # Одна строка
print(result)  # (1, 'John', 'john@example.com')

# Закрытие соединения
cursor.close()
connection.close()

2. mysql-connector-python (официальный драйвер от MySQL)

import mysql.connector

# Установка: pip install mysql-connector-python

connection = mysql.connector.connect(
    host='localhost',
    user='root',
    password='password',
    database='mydb'
)

cursor = connection.cursor()
cursor.execute("SELECT * FROM users")

for row in cursor.fetchall():
    print(row)

connection.close()

3. MySQLdb (самый быстрый, C-расширение)

import MySQLdb

# Установка: pip install mysqlclient
# На Windows может быть проблемнее

db = MySQLdb.connect(
    host='localhost',
    user='root',
    passwd='password',
    db='mydb'
)

cursor = db.cursor()
cursor.execute("SELECT COUNT(*) FROM users")
result = cursor.fetchone()
print(f'Пользователей: {result[0]}')

db.close()

SQLAlchemy + MySQL (рекомендуемый подход)

Для современных приложений используется ORM вместо raw SQL:

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import declarative_base, Session

# Установка: pip install sqlalchemy pymysql

# Подключение
engine = create_engine('mysql+pymysql://root:password@localhost:3306/mydb')

# Определение модели
Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    email = Column(String(100))

# Создание таблиц (если их нет)
Base.metadata.create_all(engine)

# Работа с БД
with Session(engine) as session:
    # Создание
    new_user = User(name='John', email='john@example.com')
    session.add(new_user)
    session.commit()
    
    # Чтение
    user = session.query(User).filter_by(name='John').first()
    print(f'{user.name}: {user.email}')
    
    # Обновление
    user.email = 'newemail@example.com'
    session.commit()
    
    # Удаление
    session.delete(user)
    session.commit()

Django ORM (для веб-приложений)

Если вы используете Django, работа с MySQL очень проста:

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'mydb',
        'USER': 'root',
        'PASSWORD': 'password',
        'HOST': 'localhost',
        'PORT': '3306',
    }
}

# models.py
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    created_at = models.DateTimeField(auto_now_add=True)
    
    class Meta:
        db_table = 'users'

# Использование
user = User.objects.create(name='John', email='john@example.com')
user.save()

users = User.objects.filter(name='John')
for user in users:
    print(user.email)

Практический пример: Полное приложение

from sqlalchemy import create_engine, Column, Integer, String, DateTime
from sqlalchemy.orm import declarative_base, Session, sessionmaker
from datetime import datetime

# Конфигурация
DATABASE_URL = 'mysql+pymysql://root:password@localhost:3306/shop'
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

# Модель
class Product(Base):
    __tablename__ = 'products'
    
    id = Column(Integer, primary_key=True)
    name = Column(String(100), nullable=False)
    price = Column(Integer, nullable=False)
    created_at = Column(DateTime, default=datetime.utcnow)

# Создание таблицы
Base.metadata.create_all(bind=engine)

# Сервис для работы с БД
class ProductService:
    def __init__(self, db: Session):
        self.db = db
    
    def create_product(self, name: str, price: int) -> Product:
        product = Product(name=name, price=price)
        self.db.add(product)
        self.db.commit()
        self.db.refresh(product)
        return product
    
    def get_product(self, product_id: int) -> Product:
        return self.db.query(Product).filter(
            Product.id == product_id
        ).first()
    
    def list_products(self) -> list[Product]:
        return self.db.query(Product).all()
    
    def update_product(self, product_id: int, name: str, price: int):
        product = self.get_product(product_id)
        if product:
            product.name = name
            product.price = price
            self.db.commit()
        return product
    
    def delete_product(self, product_id: int):
        product = self.get_product(product_id)
        if product:
            self.db.delete(product)
            self.db.commit()

# Использование
db = SessionLocal()
service = ProductService(db)

# Создание
product = service.create_product('Ноутбук', 50000)
print(f'Создан: {product.name}')

# Чтение
product = service.get_product(1)
print(f'Найден: {product.name}')

# Обновление
service.update_product(1, 'Ноутбук Pro', 60000)

# Список
all_products = service.list_products()
for p in all_products:
    print(f'{p.name}: {p.price} руб.')

# Удаление
service.delete_product(1)

db.close()

Сравнение драйверов

Лучшие практики

1. Используй ORM (SQLAlchemy, Django ORM)

# ❌ Плохо — raw SQL с конкатенацией
query = f"SELECT * FROM users WHERE id = {user_id}"  # SQL инъекция!
cursor.execute(query)

# ✅ Хорошо — параметризованный запрос
query = "SELECT * FROM users WHERE id = %s"
cursor.execute(query, (user_id,))

# ✅ Лучше — ORM
user = session.query(User).filter_by(id=user_id).first()

2. Используй connection pooling

from sqlalchemy import create_engine

engine = create_engine(
    'mysql+pymysql://user:pass@localhost/db',
    pool_size=10,  # Размер пула соединений
    max_overflow=20,  # Максимальное переполнение
    pool_pre_ping=True,  # Проверка соединения перед использованием
)

3. Обработка ошибок

try:
    connection = pymysql.connect(...)
    cursor = connection.cursor()
    cursor.execute(sql)
    connection.commit()
except pymysql.IntegrityError:
    print('Ошибка целостности данных')
except pymysql.OperationalError:
    print('Ошибка подключения')
finally:
    cursor.close()
    connection.close()

Итог: Python отлично работает с MySQL через разные драйверы. Для новых проектов рекомендуется использовать SQLAlchemy ORM, так как это современно, безопасно и удобно.