Python数据库编程全指南SQLite和MySQL实践

算子紧缩结

本文分享自华为云社区《Python数据库编程全指南SQLite和MySQL实践》，作者： 柠檬味拥抱。
1. 安装必要的库

首先，我们需要安装Python的数据库驱动程序，以便与SQLite和MySQL进行交互。对于SQLite，Python自带了支持；而对于MySQL，我们需要安装额外的库，如mysql-connector-python。

1. # 安装 MySQL 连接器
2. pip install mysql-connector-python

复制代码

2. 连接SQLite数据库

SQLite是一种轻量级的嵌入式数据库，无需服务器即可使用。以下是如何连接并操作SQLite数据库的示例代码：

1. import sqlite3
3. # 连接到 SQLite 数据库
4. conn = sqlite3.connect('example.db')
6. # 创建一个游标对象
7. cursor = conn.cursor()
9. # 创建表
10. cursor.execute('''CREATE TABLE IF NOT EXISTS users
11.                   (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
13. # 插入数据
14. cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
15. cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
17. # 查询数据
18. cursor.execute("SELECT * FROM users")
19. rows = cursor.fetchall()
20. for row in rows:
21.     print(row)
23. # 提交并关闭连接
24. conn.commit()
25. conn.close()

复制代码

3. 连接MySQL数据库

MySQL是一种常见的关系型数据库管理系统。使用Python连接MySQL需要使用相应的库，比如mysql-connector-python。以下是连接并操作MySQL数据库的示例代码：

1. import mysql.connector
3. # 连接到 MySQL 数据库
4. conn = mysql.connector.connect(
5.     host="localhost",
6.     user="username",
7.     password="password",
8.     database="mydatabase"
9. )
11. # 创建一个游标对象
12. cursor = conn.cursor()
14. # 创建表
15. cursor.execute('''CREATE TABLE IF NOT EXISTS users
16.                   (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(255), age INT)''')
18. # 插入数据
19. sql = "INSERT INTO users (name, age) VALUES (%s, %s)"
20. val = ("Alice", 30)
21. cursor.execute(sql, val)
23. # 查询数据
24. cursor.execute("SELECT * FROM users")
25. rows = cursor.fetchall()
26. for row in rows:
27.     print(row)
29. # 提交并关闭连接
30. conn.commit()
31. conn.close()

复制代码

4. 代码解析

• 连接数据库：使用sqlite3.connect()连接SQLite数据库，使用mysql.connector.connect()连接MySQL数据库。
  
• 创建表：通过执行SQL语句创建表，使用cursor.execute()方法执行。
  
• 插入数据：执行插入数据的SQL语句，使用cursor.execute()方法并传入参数。
  
• 查询数据：执行查询数据的SQL语句，使用cursor.execute()方法，然后使用cursor.fetchall()获取所有查询结果。
  
• 提交和关闭连接：对于SQLite，使用conn.commit()提交事务并使用conn.close()关闭连接。对于MySQL，同样使用conn.commit()提交事务，但需要使用conn.close()关闭连接。
  

通过这些示例代码，你可以轻松地使用Python连接和操作SQLite和MySQL数据库。务必记住在实际应用中，要处理好异常情况，并采取安全措施，如防止SQL注入等。
5. 数据库连接参数

在连接数据库时，需要提供一些参数以确保正确的连接。对于SQLite，只需提供数据库文件的路径即可。而对于MySQL，除了数据库名称外，还需要提供主机名、用户名和密码等信息。

• 对于SQLite连接：
  

1. sqlite3.connect('example.db')

复制代码

• 对于MySQL连接：
  1. conn = mysql.connector.connect(
  2.     host="localhost",
  3.     user="username",
  4.     password="password",
  5.     database="mydatabase"
  6. )

  复制代码

6. 数据库操作的异常处理

在实际应用中，数据库操作可能会出现各种异常情况，比如连接失败、SQL语法错误等。因此，在进行数据库操作时，务必添加适当的异常处理机制，以提高程序的健壮性和稳定性。
以下是一个简单的异常处理示例：

1. import sqlite3
2. import mysql.connector
4. try:
5.     # SQLite 连接
6.     conn_sqlite = sqlite3.connect('example.db')
7.     cursor_sqlite = conn_sqlite.cursor()
9.     # MySQL 连接
10.     conn_mysql = mysql.connector.connect(
11.         host="localhost",
12.         user="username",
13.         password="password",
14.         database="mydatabase"
15.     )
16.     cursor_mysql = conn_mysql.cursor()
18.     # 进行数据库操作（省略）
20. except sqlite3.Error as e:
21.     print("SQLite error:", e)
23. except mysql.connector.Error as e:
24.     print("MySQL error:", e)
26. finally:
27.     # 关闭连接
28.     if conn_sqlite:
29.         conn_sqlite.close()
30.     if conn_mysql:
31.         conn_mysql.close()

复制代码

7. 参数化查询

在执行SQL语句时，尤其是涉及用户输入的情况下，应该使用参数化查询来防止SQL注入攻击。参数化查询可以确保用户输入不会被误解为SQL代码的一部分。
下面是一个使用参数化查询的示例：

1. import sqlite3
2. import mysql.connector
4. # SQLite 连接
5. conn_sqlite = sqlite3.connect('example.db')
6. cursor_sqlite = conn_sqlite.cursor()
8. # MySQL 连接
9. conn_mysql = mysql.connector.connect(
10.     host="localhost",
11.     user="username",
12.     password="password",
13.     database="mydatabase"
14. )
15. cursor_mysql = conn_mysql.cursor()
17. # 参数化查询
18. name = "Alice"
19. age = 30
21. # SQLite 参数化查询
22. cursor_sqlite.execute("INSERT INTO users (name, age) VALUES (?, ?)", (name, age))
24. # MySQL 参数化查询
25. sql = "INSERT INTO users (name, age) VALUES (%s, %s)"
26. val = (name, age)
27. cursor_mysql.execute(sql, val)
29. # 提交事务并关闭连接
30. conn_sqlite.commit()
31. conn_sqlite.close()
33. conn_mysql.commit()
34. conn_mysql.close()

复制代码

8. ORM框架

ORM（Object-Relational Mapping）框架可以将数据库表的行映射为Python对象，简化了数据库操作。在Python中，有许多流行的ORM框架，比如SQLAlchemy、Django的ORM等。这些框架提供了高级的抽象和功能，使得与数据库的交互更加方便和直观。
以下是一个使用SQLAlchemy进行数据库操作的示例：

1. from sqlalchemy import create_engine, Column, Integer, String
2. from sqlalchemy.ext.declarative import declarative_base
3. from sqlalchemy.orm import sessionmaker
5. # 创建引擎
6. engine = create_engine('sqlite:///example.db', echo=True)
8. # 声明基类
9. Base = declarative_base()
11. # 定义映射类
12. class User(Base):
13.     __tablename__ = 'users'
15.     id = Column(Integer, primary_key=True)
16.     name = Column(String)
17.     age = Column(Integer)
19. # 创建数据表
20. Base.metadata.create_all(engine)
22. # 创建会话
23. Session = sessionmaker(bind=engine)
24. session = Session()
26. # 插入数据
27. user1 = User(name='Alice', age=30)
28. user2 = User(name='Bob', age=25)
29. session.add(user1)
30. session.add(user2)
31. session.commit()
33. # 查询数据
34. users = session.query(User).all()
35. for user in users:
36.     print(user.id, user.name, user.age)
38. # 关闭会话
39. session.close()

复制代码

9. 使用SQLite内存数据库

除了连接到文件中的SQLite数据库，还可以使用SQLite内存数据库。SQLite内存数据库完全存储在RAM中，对于临时性的数据处理或测试非常方便。
以下是一个使用SQLite内存数据库的示例：

1. import sqlite3
3. # 连接到内存数据库
4. conn = sqlite3.connect(':memory:')
6. # 创建一个游标对象
7. cursor = conn.cursor()
9. # 创建表
10. cursor.execute('''CREATE TABLE users
11.                   (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
13. # 插入数据
14. cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
15. cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
17. # 查询数据
18. cursor.execute("SELECT * FROM users")
19. rows = cursor.fetchall()
20. for row in rows:
21.     print(row)
23. # 提交并关闭连接
24. conn.commit()
25. conn.close()

复制代码

10. 数据库连接池

在高并发的应用中，频繁地打开和关闭数据库连接会消耗大量资源。为了提高性能，可以使用数据库连接池技术，将数据库连接预先创建好并保存在池中，需要时从池中获取连接，使用完毕后归还到池中。
以下是使用sqlitepool库实现SQLite数据库连接池的示例：

1. from sqlitepool import ConnectionPool
3. # 创建数据库连接池
4. pool = ConnectionPool('example.db', max_connections=5)
6. # 从连接池中获取连接
7. conn = pool.getconn()
9. # 创建游标对象
10. cursor = conn.cursor()
12. # 执行查询
13. cursor.execute("SELECT * FROM users")
14. rows = cursor.fetchall()
15. for row in rows:
16.     print(row)
18. # 释放连接回连接池
19. pool.putconn(conn)

复制代码

11. 性能优化

在进行大规模数据操作时，需要考虑性能优化。一些常见的性能优化策略包括：

• 使用索引来加速查询。
  
• 合理设计数据库结构，避免过度规范化或反规范化。
  
• 批量操作数据，减少数据库交互次数。
  
• 缓存查询结果，减少重复查询数据库的次数。
  

12. 使用异步数据库库

随着异步编程的流行，出现了许多支持异步操作的数据库库，如aiosqlite和aiomysql。这些库可以与异步框架（如asyncio）结合使用，提高程序的并发性能。
以下是一个使用aiosqlite库进行异步SQLite数据库操作的示例：

1. import asyncio
2. import aiosqlite
4. async def main():
5.     # 连接到 SQLite 数据库
6.     async with aiosqlite.connect('example.db') as db:
7.         # 创建一个游标对象
8.         cursor = await db.cursor()
10.         # 创建表
11.         await cursor.execute('''CREATE TABLE IF NOT EXISTS users
12.                                (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
14.         # 插入数据
15.         await cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
16.         await cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 25))
18.         # 查询数据
19.         await cursor.execute("SELECT * FROM users")
20.         rows = await cursor.fetchall()
21.         for row in rows:
22.             print(row)
24. # 运行异步主程序
25. asyncio.run(main())

复制代码

13. 数据库迁移

在实际项目中，随着需求的变化，可能需要对数据库结构进行修改，这时候就需要进行数据库迁移（Migration）。数据库迁移工具可以帮助我们管理数据库结构变更的过程，并确保数据的一致性。
对于SQLite，可以使用sqlite3自带的支持。对于MySQL等数据库，常用的迁移工具包括Alembic、django.db.migrations等。
以下是一个简单的数据库迁移示例（以SQLite为例）：

1. import sqlite3
3. # 连接到 SQLite 数据库
4. conn = sqlite3.connect('example.db')
5. cursor = conn.cursor()
7. # 执行迁移操作（修改表结构）
8. cursor.execute("ALTER TABLE users ADD COLUMN email TEXT")
10. # 提交并关闭连接
11. conn.commit()
12. conn.close()

复制代码

14. 备份与恢复

定期备份数据库是保障数据安全的重要措施之一。备份可以通过数据库管理工具或编程方式来实现，具体方法取决于数据库类型和需求。
以下是一个简单的备份数据库的示例（以SQLite为例）：

1. import shutil
3. # 备份数据库文件
4. shutil.copyfile('example.db', 'example_backup.db')

复制代码

在实际应用中，备份数据库时需要考虑数据库是否处于活动状态、备份文件存储位置、备份周期等因素。
15. 使用环境变量管理数据库连接信息

在实际项目中，将数据库连接信息硬编码在代码中可能不够安全或不够灵活。一种更好的做法是使用环境变量来管理敏感信息，比如数据库的主机名、用户名和密码等。
以下是一个使用环境变量管理数据库连接信息的示例：

1. import os
2. import sqlite3
3. import mysql.connector
5. # 从环境变量中获取数据库连接信息
6. DB_HOST = os.getenv('DB_HOST', 'localhost')
7. DB_USER = os.getenv('DB_USER', 'username')
8. DB_PASSWORD = os.getenv('DB_PASSWORD', 'password')
9. DB_NAME = os.getenv('DB_NAME', 'mydatabase')
11. # SQLite 连接
12. conn_sqlite = sqlite3.connect('example.db')
13. cursor_sqlite = conn_sqlite.cursor()
15. # MySQL 连接
16. conn_mysql = mysql.connector.connect(
17.     host=DB_HOST,
18.     user=DB_USER,
19.     password=DB_PASSWORD,
20.     database=DB_NAME
21. )
22. cursor_mysql = conn_mysql.cursor()
24. # 进行数据库操作（省略）
26. # 关闭连接
27. conn_sqlite.close()
28. conn_mysql.close()

复制代码

通过使用环境变量，我们可以轻松地在不同的环境中切换数据库连接信息，而无需修改代码。
16. 使用配置文件管理数据库连接信息

除了使用环境变量，还可以使用配置文件来管理数据库连接信息。这种方法更加灵活，可以根据需要配置不同的环境，如开发环境、测试环境和生产环境等。
以下是一个使用配置文件管理数据库连接信息的示例：

1. import configparser
2. import sqlite3
3. import mysql.connector
5. # 从配置文件中读取数据库连接信息
6. config = configparser.ConfigParser()
7. config.read('config.ini')
9. DB_HOST = config.get('Database', 'host')
10. DB_USER = config.get('Database', 'user')
11. DB_PASSWORD = config.get('Database', 'password')
12. DB_NAME = config.get('Database', 'database')
14. # SQLite 连接
15. conn_sqlite = sqlite3.connect('example.db')
16. cursor_sqlite = conn_sqlite.cursor()
18. # MySQL 连接
19. conn_mysql = mysql.connector.connect(
20.     host=DB_HOST,
21.     user=DB_USER,
22.     password=DB_PASSWORD,
23.     database=DB_NAME
24. )
25. cursor_mysql = conn_mysql.cursor()
27. # 进行数据库操作（省略）
29. # 关闭连接
30. conn_sqlite.close()
31. conn_mysql.close()

复制代码

通过配置文件的方式，我们可以将数据库连接信息集中管理，便于维护和修改。
17. 数据库连接的安全性考虑

在连接数据库时，需要考虑安全性问题，特别是涉及到密码和敏感信息的处理。一些常见的安全性措施包括：

• 不要将敏感信息硬编码在代码中，而是使用环境变量或配置文件管理。
  
• 使用加密技术保护敏感信息在传输过程中的安全性。
  
• 使用强密码，并定期更换密码。
  
• 限制数据库用户的权限，避免赋予过高的权限。
  

通过采取这些安全性措施，可以有效保护数据库连接信息和数据的安全。
总结

本文介绍了使用Python进行数据库连接与操作的多种方法和技术。首先，我们学习了如何使用Python连接和操作SQLite和MySQL数据库，包括创建表、插入数据、查询数据等基本操作。然后，我们探讨了一些高级技术，如参数化查询、ORM框架、异步数据库库、数据库迁移、备份与恢复等，这些技术可以提高数据库操作的效率和安全性。此外，我们还介绍了如何使用环境变量和配置文件来管理数据库连接信息，以及一些数据库连接的安全性考虑。通过这些技术和方法，我们可以更好地管理和保护数据库，使得数据库编程更加安全、灵活和高效。
在实际项目中，我们需要根据项目需求和安全标准选择合适的技术和工具，确保数据库连接和操作的安全性和可靠性。同时，我们也要不断学习和探索新的技术，以跟上数据库领域的发展和变化。希望本文能够帮助读者更好地理解和应用Python数据库编程的相关知识，为实际项目开发提供帮助和指导。
点击关注，第一时间了解华为云新鲜技术~
 

来源:https://www.cnblogs.com/huaweiyun/p/18101010
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！