Python连接MySQL数据库的完整指南与实践-代码聚汇网

Python连接MySQL数据库的完整指南与实践

二号猎人·2026-08-13·阅读 24 GEO检测（免费）

PythonMySQL数据库连接

|难度：普通|阅读约 33 分钟

1. 为什么Python需要连接MySQL数据库？

在当今数据驱动的时代，数据库已经成为几乎所有应用程序的核心组件。MySQL作为最流行的开源关系型数据库之一，与Python这门同样广受欢迎的编程语言结合，能够为开发者提供强大的数据处理能力。

Python连接MySQL的典型应用场景包括：

Web开发中的数据存储（如Django、Flask等框架）
数据分析与科学计算（如Pandas处理大规模数据集）
自动化脚本与数据处理管道
机器学习模型的训练数据存储

我曾在多个电商数据分析项目中深度使用Python+MySQL组合，其中一个典型案例是处理每日超过500万条的交易记录。通过Python的灵活性与MySQL的高效存储，我们实现了近乎实时的销售数据分析和报表生成。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 环境准备与依赖安装

2.1 Python环境确认

在开始之前，请确保你已经安装了Python环境。推荐使用Python 3.6及以上版本，可以通过以下命令检查：

bash复制python --version
# 或
python3 --version

如果你看到类似"Python 3.8.5"的输出，说明环境已就绪。如果尚未安装，可以从Python官网下载对应操作系统的安装包。

2.2 MySQL安装与配置

MySQL的安装方式因操作系统而异：

Windows系统：

从MySQL官网下载MySQL Installer
运行安装程序，选择"Developer Default"配置
设置root用户密码（务必牢记）
完成安装后，可以通过MySQL Command Line Client验证

macOS系统：

bash复制brew install mysql
brew services start mysql

Linux系统（以Ubuntu为例）：

bash复制sudo apt update
sudo apt install mysql-server
sudo mysql_secure_installation

安装完成后，确保MySQL服务正在运行：

bash复制sudo systemctl status mysql

2.3 Python连接MySQL的驱动选择

Python有多个库可以连接MySQL，最常用的两个是：

mysql-connector-python：MySQL官方提供的纯Python驱动
```
bash复制pip install mysql-connector-python
```
PyMySQL：纯Python实现的MySQL客户端
```
bash复制pip install pymysql
```
MySQLdb：C扩展实现的接口（仅Python 2.x，不推荐新项目使用）

我个人更推荐使用mysql-connector-python，因为它由MySQL官方维护，兼容性最好，且支持最新的MySQL特性。

3. 基础连接与操作

3.1 建立数据库连接

以下是使用mysql-connector-python建立连接的完整示例：

python复制import mysql.connector
from mysql.connector import Error

try:
    connection = mysql.connector.connect(
        host='localhost',
        user='your_username',
        password='your_password',
        database='your_database'
    )
    
    if connection.is_connected():
        db_info = connection.get_server_info()
        print(f"成功连接到MySQL Server版本 {db_info}")
        
except Error as e:
    print(f"连接错误: {e}")
finally:
    if connection and connection.is_connected():
        connection.close()
        print("MySQL连接已关闭")

关键参数说明：

host：MySQL服务器地址，本地为'localhost'
user：数据库用户名
password：对应用户的密码
database：要连接的特定数据库名（可选）

重要提示：永远不要在代码中硬编码数据库凭证！应该使用环境变量或配置文件来管理敏感信息。

3.2 执行SQL查询

连接成功后，我们可以执行各种SQL操作：

python复制try:
    connection = mysql.connector.connect(
        host='localhost',
        user='root',
        password='password',
        database='test_db'
    )
    
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM customers")
    
    # 获取所有记录
    records = cursor.fetchall()
    print("总记录数:", cursor.rowcount)
    
    for row in records:
        print(row)
        
except Error as e:
    print(f"查询错误: {e}")
finally:
    if connection.is_connected():
        cursor.close()
        connection.close()

3.3 参数化查询

为了防止SQL注入，应该始终使用参数化查询：

python复制# 安全的方式 - 使用参数化查询
query = "INSERT INTO employees (name, department) VALUES (%s, %s)"
values = ("John Doe", "Engineering")

cursor.execute(query, values)
connection.commit()
print(cursor.rowcount, "条记录插入成功")

4. 高级操作与最佳实践

4.1 使用连接池管理连接

在高并发应用中，频繁创建和关闭连接会影响性能。使用连接池可以显著提高效率：

python复制from mysql.connector import pooling

# 创建连接池
connection_pool = pooling.MySQLConnectionPool(
    pool_name="my_pool",
    pool_size=5,
    host='localhost',
    user='root',
    password='password',
    database='test_db'
)

# 从池中获取连接
connection = connection_pool.get_connection()

if connection.is_connected():
    print("从连接池获取连接成功")
    # 执行查询...
    
# 连接会自动返回到池中

4.2 事务处理

对于需要原子性操作的一组SQL语句，应该使用事务：

python复制try:
    connection.start_transaction()
    
    cursor.execute("UPDATE accounts SET balance = balance - 100 WHERE id = 1")
    cursor.execute("UPDATE accounts SET balance = balance + 100 WHERE id = 2")
    
    connection.commit()
    print("事务提交成功")
    
except Error as e:
    connection.rollback()
    print(f"事务回滚: {e}")

4.3 使用上下文管理器

Python的上下文管理器可以自动处理连接的打开和关闭：

python复制from contextlib import contextmanager

@contextmanager
def get_db_connection():
    conn = None
    try:
        conn = mysql.connector.connect(
            host='localhost',
            user='root',
            password='password',
            database='test_db'
        )
        yield conn
    except Error as e:
        print(f"数据库错误: {e}")
    finally:
        if conn and conn.is_connected():
            conn.close()

# 使用示例
with get_db_connection() as connection:
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM products")
    results = cursor.fetchall()
    for row in results:
        print(row)

5. 常见问题与解决方案

5.1 连接超时问题

MySQL服务器默认会在8小时不活动后关闭连接。可以通过以下方式解决：

python复制# 在连接配置中添加重连参数
connection = mysql.connector.connect(
    host='localhost',
    user='root',
    password='password',
    database='test_db',
    pool_name='my_pool',
    pool_size=5,
    autocommit=True,
    pool_reset_session=True,
    connection_timeout=300
)

5.2 字符编码问题

确保连接使用UTF-8编码以避免中文乱码：

python复制connection = mysql.connector.connect(
    host='localhost',
    user='root',
    password='password',
    database='test_db',
    charset='utf8mb4',
    collation='utf8mb4_unicode_ci'
)

5.3 大数据量处理

当处理大量数据时，可以使用服务器端游标减少内存占用：

python复制cursor = connection.cursor(buffered=False)  # 服务器端游标
cursor.execute("SELECT * FROM large_table")

while True:
    batch = cursor.fetchmany(1000)  # 每次获取1000条
    if not batch:
        break
    process_batch(batch)

6. 性能优化技巧

6.1 批量插入数据

相比单条插入，批量插入可以显著提高性能：

python复制data = [
    ('Product1', 10.99),
    ('Product2', 20.50),
    ('Product3', 15.75)
]

query = "INSERT INTO products (name, price) VALUES (%s, %s)"
cursor.executemany(query, data)
connection.commit()

6.2 使用索引加速查询

确保经常查询的列上有适当的索引：

python复制# 创建索引
cursor.execute("CREATE INDEX idx_name ON customers(name)")

6.3 查询优化

只选择需要的列，避免使用SELECT *：

python复制# 不好的做法
cursor.execute("SELECT * FROM customers")

# 好的做法 - 只选择需要的列
cursor.execute("SELECT id, name, email FROM customers WHERE status = 'active'")

7. 实际项目中的应用示例

7.1 与Pandas集成

Python的数据分析库Pandas可以方便地与MySQL交互：

python复制import pandas as pd
from sqlalchemy import create_engine

# 创建SQLAlchemy引擎
engine = create_engine('mysql+mysqlconnector://root:password@localhost/test_db')

# 读取数据到DataFrame
df = pd.read_sql("SELECT * FROM sales", engine)

# 数据分析操作
monthly_sales = df.groupby(pd.to_datetime(df['date']).dt.month)['amount'].sum()

# 写回数据库
df.to_sql('sales_report', engine, if_exists='replace', index=False)

7.2 Web应用中的使用

在Flask Web应用中使用MySQL的典型模式：

python复制from flask import Flask
import mysql.connector

app = Flask(__name__)

def get_db():
    if not hasattr(g, 'mysql_db'):
        g.mysql_db = mysql.connector.connect(
            host='localhost',
            user='flask_user',
            password='secure_password',
            database='flask_app'
        )
    return g.mysql_db

@app.route('/users')
def list_users():
    db = get_db()
    cursor = db.cursor(dictionary=True)  # 返回字典形式的结果
    cursor.execute("SELECT id, username, email FROM users")
    users = cursor.fetchall()
    return {'users': users}

@app.teardown_appcontext
def close_db(error):
    if hasattr(g, 'mysql_db'):
        g.mysql_db.close()

7.3 自动化数据处理管道

构建一个从MySQL提取数据、处理后再存储的自动化管道：

python复制import mysql.connector
from datetime import datetime, timedelta

def process_daily_data():
    yesterday = (datetime.now() - timedelta(1)).strftime('%Y-%m-%d')
    
    try:
        # 源数据库连接
        src_conn = mysql.connector.connect(
            host='source_host',
            user='reader',
            password='reader_pass',
            database='source_db'
        )
        
        # 目标数据库连接
        dest_conn = mysql.connector.connect(
            host='dest_host',
            user='writer',
            password='writer_pass',
            database='data_warehouse'
        )
        
        # 提取数据
        src_cursor = src_conn.cursor(dictionary=True)
        query = f"""
            SELECT user_id, SUM(amount) as total_spent 
            FROM transactions 
            WHERE date = '{yesterday}' 
            GROUP BY user_id
        """
        src_cursor.execute(query)
        
        # 处理并加载数据
        dest_cursor = dest_conn.cursor()
        for row in src_cursor:
            # 这里可以添加任何数据处理逻辑
            dest_cursor.execute(
                "INSERT INTO daily_spending (date, user_id, amount) VALUES (%s, %s, %s)",
                (yesterday, row['user_id'], row['total_spent'])
            )
        
        dest_conn.commit()
        print(f"成功处理{yesterday}的数据")
        
    except Exception as e:
        print(f"处理失败: {e}")
    finally:
        if 'src_conn' in locals() and src_conn.is_connected():
            src_conn.close()
        if 'dest_conn' in locals() and dest_conn.is_connected():
            dest_conn.close()

# 每天凌晨1点运行
schedule.every().day.at("01:00").do(process_daily_data)

8. 安全注意事项

8.1 凭证管理

永远不要将数据库凭证硬编码在源代码中。推荐的做法：

使用环境变量：

python复制import os
db_config = {
    'host': os.getenv('DB_HOST'),
    'user': os.getenv('DB_USER'),
    'password': os.getenv('DB_PASSWORD'),
    'database': os.getenv('DB_NAME')
}

使用配置文件（如config.ini）：

ini复制[database]
host = localhost
user = app_user
password = secure_password
database = app_db

然后在Python中读取：

python复制import configparser
config = configparser.ConfigParser()
config.read('config.ini')
db_config = config['database']

8.2 SQL注入防护

除了使用参数化查询外，还应：

对用户输入进行验证和清理
使用ORM框架（如SQLAlchemy）可以自动处理大部分安全问题
限制数据库用户的权限（遵循最小权限原则）

8.3 连接安全

对于生产环境：

使用SSL加密连接：

python复制connection = mysql.connector.connect(
    host='prod-db.example.com',
    user='app_user',
    password='secure_password',
    database='app_db',
    ssl_ca='/path/to/ca.pem',
    ssl_cert='/path/to/client-cert.pem',
    ssl_key='/path/to/client-key.pem'
)

考虑使用SSH隧道连接远程数据库
定期轮换数据库凭证

9. 调试与故障排除

9.1 常见错误处理

OperationalError: Lost connection to MySQL server
- 检查MySQL服务是否运行
- 增加连接超时时间
- 使用连接池管理连接
ProgrammingError: Not all parameters were used
- 检查SQL语句中的占位符数量与参数数量是否匹配
- 确保参数是元组或列表形式
IntegrityError: Duplicate entry
- 检查是否有唯一键冲突
- 考虑使用INSERT IGNORE或ON DUPLICATE KEY UPDATE

9.2 日志记录

配置详细的日志记录有助于诊断问题：

python复制import logging
from mysql.connector import connect, Error

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger('mysql')

try:
    connection = connect(
        host='localhost',
        user='root',
        password='password',
        database='test_db'
    )
    logger.info("数据库连接成功")
    
except Error as e:
    logger.error(f"数据库连接失败: {e}")

9.3 性能分析

使用EXPLAIN分析查询性能：

python复制cursor.execute("EXPLAIN SELECT * FROM orders WHERE customer_id = %s", (123,))
for row in cursor:
    print(row)

10. 替代方案与扩展

10.1 ORM框架

对于大型应用，考虑使用ORM框架如SQLAlchemy或Django ORM：

python复制# SQLAlchemy示例
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

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

# 创建引擎和会话
engine = create_engine('mysql+mysqlconnector://root:password@localhost/test_db')
Session = sessionmaker(bind=engine)
session = Session()

# 查询示例
users = session.query(User).filter(User.name.like('%John%')).all()
for user in users:
    print(user.name, user.email)

10.2 异步MySQL驱动

对于异步应用，可以使用aiomysql：

python复制import asyncio
import aiomysql

async def fetch_data():
    conn = await aiomysql.connect(
        host='localhost',
        user='root',
        password='password',
        db='test_db'
    )
    
    async with conn.cursor() as cursor:
        await cursor.execute("SELECT * FROM products")
        result = await cursor.fetchall()
        print(result)
    
    conn.close()

loop = asyncio.get_event_loop()
loop.run_until_complete(fetch_data())

10.3 其他数据库适配

同样的模式可以应用于其他数据库：

PostgreSQL：使用psycopg2
SQLite：内置sqlite3模块
Oracle：使用cx_Oracle

掌握Python连接MySQL的技能后，这些数据库的学习曲线会大大降低。