当前位置：首页 > 文章列表 > 文章 > python教程 > Python轻松连接SQLite数据库教程

Python轻松连接SQLite数据库教程

2025-08-05 21:30:13 0浏览收藏

偷偷努力，悄无声息地变强，然后惊艳所有人！哈哈，小伙伴们又来学习啦~今天我将给大家介绍《Python连接SQLite教程：轻量级数据库操作指南》，这篇文章主要会讲到等等知识点，不知道大家对其都有多少了解，下面我们就一起来看一吧！当然，非常希望大家能多多评论，给出合理的建议，我们一起学习，一起进步！

Python操作SQLite的核心在于使用内置的sqlite3模块，其基本流程包括：1. 使用sqlite3.connect()建立连接；2. 通过conn.cursor()创建游标；3. 执行SQL语句进行建表、增删改查等操作；4. 涉及数据修改时调用conn.commit()提交事务；5. 操作完成后关闭连接以释放资源。为有效处理异常，应使用try-except-finally结构或with语句捕获sqlite3.Error及其子类（如IntegrityError、OperationalError），并在出错时执行conn.rollback()回滚事务，确保数据一致性。性能优化方面，推荐使用executemany()批量插入数据、显式事务管理减少提交次数、合理创建索引加速查询、启用WAL模式提升并发性能，并可通过PRAGMA指令调整缓存和同步策略。高级用法包括：设置conn.row_factory = sqlite3.Row实现按列名访问查询结果；使用conn.create_function()注册自定义SQL函数；利用:memory:创建内存数据库用于测试或临时计算；注意多线程环境下应为每个线程创建独立连接以避免线程安全问题。这些方法共同构成了Python高效、安全操作SQLite的完整实践方案。

Python如何连接SQLite？轻量级数据库操作

Python连接SQLite，核心是通过其内置的sqlite3模块。这个过程通常涉及几个关键步骤：建立连接、创建游标、执行SQL语句、提交更改（如果涉及数据修改）以及最后关闭数据库连接。它不像那些大型数据库需要复杂的配置，SQLite的轻量级特性让它在本地应用或原型开发中显得异常方便。

解决方案

要连接和操作SQLite数据库，以下是一个基本的流程和代码示例：

import sqlite3

def connect_and_operate_sqlite():
    conn = None # 初始化连接对象
    try:
        # 连接到数据库文件。如果文件不存在，会自动创建。
        # ':memory:' 可以创建一个内存数据库，不保存到文件。
        conn = sqlite3.connect('my_database.db')
        print("数据库连接成功！")

        # 创建一个游标对象，用于执行SQL命令
        cursor = conn.cursor()

        # 示例1：创建表
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                age INTEGER
            )
        ''')
        print("表 'users' 创建或已存在。")

        # 示例2：插入数据
        cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Alice', 30))
        cursor.execute("INSERT INTO users (name, age) VALUES (?, ?)", ('Bob', 24))
        # 批量插入
        users_data = [('Charlie', 35), ('David', 28)]
        cursor.executemany("INSERT INTO users (name, age) VALUES (?, ?)", users_data)
        print("数据插入成功。")

        # 提交事务，保存更改
        conn.commit()
        print("事务已提交。")

        # 示例3：查询数据
        cursor.execute("SELECT * FROM users WHERE age > ?", (25,))
        rows = cursor.fetchall() # 获取所有结果
        print("\n查询结果 (年龄 > 25):")
        for row in rows:
            print(row)

        # 示例4：更新数据
        cursor.execute("UPDATE users SET age = ? WHERE name = ?", (31, 'Alice'))
        print(f"更新了 {cursor.rowcount} 条记录。")
        conn.commit()

        # 示例5：删除数据
        cursor.execute("DELETE FROM users WHERE name = ?", ('Bob',))
        print(f"删除了 {cursor.rowcount} 条记录。")
        conn.commit()

        # 再次查询所有数据，看看变化
        cursor.execute("SELECT * FROM users")
        print("\n所有用户数据:")
        for row in cursor.fetchall():
            print(row)

    except sqlite3.Error as e:
        print(f"数据库操作发生错误: {e}")
        if conn:
            conn.rollback() # 发生错误时回滚事务
            print("事务已回滚。")
    finally:
        if conn:
            conn.close()
            print("数据库连接已关闭。")

# 调用函数执行操作
connect_and_operate_sqlite()

Python操作SQLite时，如何有效处理常见的错误和异常？

在实际开发中，代码跑着跑着就崩了，这通常是错误处理没考虑到位。Python连接SQLite时，遇到错误是很常见的，比如数据库文件损坏、SQL语法错误、数据完整性约束违反（比如插入重复的PRIMARY KEY）等等。sqlite3模块会抛出sqlite3.Error及其子类异常，比如sqlite3.OperationalError（操作错误，如数据库文件锁定）和sqlite3.IntegrityError（完整性错误，如违反唯一约束）。

我的经验是，最稳妥的做法就是使用try...except...finally结构，或者更推荐的with语句（上下文管理器）。with语句能确保连接被正确关闭，即使在操作过程中出现异常。

import sqlite3

def robust_sqlite_operation(db_name='robust_db.db'):
    try:
        # 使用with语句，连接会在代码块结束时自动关闭
        with sqlite3.connect(db_name) as conn:
            cursor = conn.cursor()

            # 尝试一个可能出错的操作，比如重复创建唯一索引的表
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS products (
                    id INTEGER PRIMARY KEY,
                    name TEXT UNIQUE NOT NULL
                )
            ''')
            print("表 'products' 创建成功或已存在。")

            # 插入一些数据
            cursor.execute("INSERT INTO products (name) VALUES (?)", ('Laptop',))
            print("插入 Laptop 成功。")
            conn.commit() # 每次操作后提交，或者批量操作后一次性提交

            # 尝试插入一个重复的name，这会引发IntegrityError
            try:
                cursor.execute("INSERT INTO products (name) VALUES (?)", ('Laptop',))
                print("插入重复的 Laptop 成功 (理论上不应该发生)。")
            except sqlite3.IntegrityError as e:
                print(f"捕获到完整性错误: {e} - 'Laptop' 已经存在。")
                conn.rollback() # 遇到错误时回滚，避免部分提交
            except sqlite3.OperationalError as e:
                print(f"捕获到操作错误: {e}")
                conn.rollback()
            except sqlite3.Error as e: # 更通用的SQLite错误
                print(f"捕获到其他SQLite错误: {e}")
                conn.rollback()

            # 正常查询
            cursor.execute("SELECT * FROM products")
            print("\n当前产品列表:")
            for row in cursor.fetchall():
                print(row)

    except sqlite3.Error as e:
        print(f"外部捕获到数据库连接或初始化错误: {e}")
    except Exception as e:
        print(f"捕获到非数据库相关错误: {e}")

robust_sqlite_operation()

这里，conn.rollback()在捕获到错误时显得尤为重要，它能撤销当前事务中所有未提交的更改，确保数据库状态的一致性。

在Python中，如何优化SQLite数据库的读写性能？

性能优化在处理大量数据时变得至关重要。我刚开始写代码的时候，可能只顾着功能实现，但数据量一上来，性能问题就暴露了，比如批量插入几万条数据慢得像蜗牛。对于SQLite，有一些技巧可以显著提升读写效率：

批量插入 (executemany)： 这是最直接有效的优化。相比于循环里一条条execute，executemany能大大减少数据库的交互次数。

import sqlite3
conn = sqlite3.connect('bulk_insert.db')
cursor = conn.cursor()
cursor.execute('CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, value TEXT)')

data_to_insert = [(i, f'Item {i}') for i in range(10000)] # 1万条数据

# 方式一：循环插入（慢）
# import time
# start_time = time.time()
# for item in data_to_insert:
#     cursor.execute("INSERT INTO items (id, value) VALUES (?, ?)", item)
# conn.commit()
# print(f"循环插入10000条数据耗时: {time.time() - start_time:.4f}秒")

# 方式二：使用 executemany（快）
import time
start_time = time.time()
cursor.executemany("INSERT INTO items (id, value) VALUES (?, ?)", data_to_insert)
conn.commit()
print(f"executemany插入10000条数据耗时: {time.time() - start_time:.4f}秒")
conn.close()

你会发现executemany的速度简直是碾压式的。

事务管理： 显式地将多个操作包裹在一个事务中。默认情况下，SQLite的每个execute语句都是一个独立的事务。将一系列相关的操作放在一个BEGIN TRANSACTION和COMMIT之间，可以减少磁盘I/O。conn.commit()就是提交当前事务。对于大量写入，可以只在所有操作完成后提交一次。
索引（Indexes）： 这不是Python层面的优化，而是数据库设计层面的。在经常用于查询条件的列上创建索引，能显著加快查询速度。
```
CREATE INDEX idx_users_name ON users (name);
```
当然，索引会增加写入操作的开销，所以需要权衡。
WAL模式（Write-Ahead Logging）： SQLite的默认日志模式是DELETE，每次提交都会将整个数据库文件锁定。WAL模式允许读写操作并行进行，并且通常在并发场景下提供更好的性能，尤其是在有大量并发读操作时。
```
conn = sqlite3.connect('wal_db.db')
cursor = conn.cursor()
cursor.execute("PRAGMA journal_mode=WAL;")
# 后续操作都会在WAL模式下进行
```
这个对我来说是个小惊喜，它能有效改善并发读写时的体验。
PRAGMA语句： SQLite提供了许多PRAGMA语句来调整其行为。
- PRAGMA synchronous = OFF;：降低写入的安全性（如果系统崩溃可能丢失数据），但能显著提高写入速度。生产环境慎用，或只在对数据丢失不敏感的场景使用。
- PRAGMA cache_size = N;：设置内存页缓存的大小，增加缓存可以减少磁盘I/O。N是页数，每页通常1KB或4KB。

这些优化手段结合起来，能让你的Python-SQLite应用在处理数据时更加流畅。

除了基础操作，Python操作SQLite还有哪些高级用法或注意事项？

用久了，你会发现有些小技巧能让代码更优雅，或者解决一些看似棘手的问题。

行工厂（Row Factories）： 默认情况下，cursor.fetchall()返回的是元组（tuple）列表，按索引访问数据可能不太直观。通过设置conn.row_factory = sqlite3.Row，你可以让查询结果以类似字典的方式访问，通过列名来获取数据，代码可读性会好很多。

import sqlite3
conn = sqlite3.connect(':memory:')
conn.row_factory = sqlite3.Row # 设置行工厂

cursor = conn.cursor()
cursor.execute("CREATE TABLE people (name TEXT, age INTEGER)")
cursor.execute("INSERT INTO people (name, age) VALUES (?, ?)", ('Alice', 30))
conn.commit()

cursor.execute("SELECT * FROM people")
row = cursor.fetchone()
print(f"通过索引访问: {row[0]}, {row[1]}")
print(f"通过列名访问: {row['name']}, {row['age']}")
conn.close()

这种方式在处理复杂查询结果时，能让代码清晰不少。

自定义SQL函数： sqlite3模块允许你注册Python函数作为SQL函数，在SQL语句中直接调用。这在需要复杂计算或业务逻辑时非常有用。

import sqlite3

def calculate_bmi(weight_kg, height_cm):
    if height_cm == 0:
        return 0
    height_m = height_cm / 100.0
    return weight_kg / (height_m * height_m)

conn = sqlite3.connect(':memory:')
# 注册Python函数为SQL函数
conn.create_function("BMI", 2, calculate_bmi) # 函数名, 参数数量, Python函数

cursor = conn.cursor()
cursor.execute("CREATE TABLE health (name TEXT, weight REAL, height REAL)")
cursor.execute("INSERT INTO health VALUES ('John', 70, 175)")
cursor.execute("INSERT INTO health VALUES ('Jane', 55, 160)")
conn.commit()

cursor.execute("SELECT name, weight, height, BMI(weight, height) AS bmi_value FROM health")
for row in cursor.fetchall():
    print(row)
conn.close()

这拓展了SQLite的表达能力，让一些原本需要在应用层处理的逻辑可以在数据库层面完成。

内存数据库 (:memory:)： 在连接字符串中使用:memory:，可以创建一个完全在内存中运行的数据库。它不会持久化到文件，在程序关闭时数据会丢失。这对于单元测试、临时数据处理或需要高性能、不需要持久化的场景非常方便。

import sqlite3
conn = sqlite3.connect(':memory:') # 创建内存数据库
# 后续操作与文件数据库无异
conn.execute("CREATE TABLE temp_data (id INTEGER, value TEXT)")
conn.execute("INSERT INTO temp_data VALUES (1, 'Test')")
cursor = conn.cursor()
cursor.execute("SELECT * FROM temp_data")
print(cursor.fetchone())
conn.close() # 关闭后数据即消失

线程安全： SQLite本身是线程安全的，但sqlite3模块的默认设置是check_same_thread=True，这意味着同一个连接对象不能在不同的线程中使用。如果你需要在多线程环境中使用SQLite，你需要为每个线程创建一个独立的连接，或者在sqlite3.connect()中设置check_same_thread=False（但这需要你自行处理并发访问的锁机制，否则可能导致数据损坏或不一致）。通常，更推荐的做法是为每个线程维护自己的数据库连接。