python连接sqlite数据库

豪豪学习8848

已于 2024-04-19 11:17:37 修改

阅读量833

点赞数 12

文章标签： oracle 数据库

于 2024-04-15 10:21:57 首次发布

本文链接：https://blog.csdn.net/weixin_45365818/article/details/137688572

版权

本文介绍了如何使用Python的sqlite3库连接SQLite数据库，创建表，插入、查询、更新和删除数据，以及强调了参数化查询和正确管理数据库资源的重要性。

摘要由CSDN通过智能技术生成

import sqlite3

# 连接到SQLite数据库
# 如果数据库文件不存在，会自动在当前目录创建:
conn = sqlite3.connect('example.db')

try:
    # 创建一个Cursor对象
    cursor = conn.cursor()

    # 创建一个新表
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY,
            name TEXT NOT NULL,
            age INTEGER
        );
    ''')

    # 插入一些数据
    cursor.execute("INSERT INTO users (name, age) VALUES ('Alice', 25)")
    cursor.execute("INSERT INTO users (name, age) VALUES ('Bob', 30)")

    # 提交更改到数据库
    conn.commit()

    # 如果需要查询数据，可以取消注释下面的代码
    # cursor.execute("SELECT * FROM users")
    # rows = cursor.fetchall()
    # for row in rows:
    #     print(row)

except sqlite3.Error as e:
    # 如果发生错误，则打印错误信息
    print(e)

finally:
    # 关闭Cursor和数据库连接
    if conn:
        cursor.close()
        conn.close()

# 程序结束

import sqlite3

sqlite是一个非常流行的轻量级数据库，它不需要单独的服务器进程，数据库就是一些文件。使用sqlite3库，您可以执行SQL命令来创建数据库、表、插入数据、查询数据等。

.cursor()

在Python中使用sqlite3库与SQLite数据库交互时，.cursor()方法是用来创建一个游标对象的。游标对象用于执行SQL语句，并提供操作数据库的接口。通过这个游标对象，你可以执行查询、更新、删除等操作，并且可以获取查询结果。

在开篇例子中，conn.cursor()创建了一个游标对象cursor。通过这个游标对象，我们执行了几个SQL语句，包括创建表、插入数据和查询数据。cursor.close()用于关闭游标，而conn.close()用于关闭与数据库的连接。

需要注意的是，每次调用.cursor()都会创建一个新的游标对象。在实际应用中，应该确保在操作完成后关闭游标和连接，以避免资源泄露。同时，使用with语句可以自动管理游标和连接的关闭，使代码更加简洁和安全：

with sqlite3.connect('example.db') as conn:
    with conn.cursor() as cursor:
        cursor.execute("SELECT * FROM users")
        rows = cursor.fetchall()
        for row in rows:
            print(row)

使用with语句的好处是，即使在执行SQL语句时发生异常，游标和连接也会被自动关闭。这样可以确保数据库资源始终得到正确的释放。

`cursor.execute()`

cursor.execute() 是 Python sqlite3 模块中用于执行 SQL 语句的一个重要方法。当你创建了一个游标对象后，你可以使用这个方法来运行 SQL 语句。这个方法可以执行查询、更新、删除和创建表等操作。cursor.execute() 方法的基本语法如下：

cursor.execute(sql, parameters)

sql 是一个字符串，包含了你想要执行的 SQL 语句。
parameters 是一个可选参数，可以是一个元组、字典或者是一个序列，用于提供 SQL 语句中的参数。

下面是一些使用 cursor.execute() 方法的例子：

创建表

cursor.execute('''
    CREATE TABLE IF NOT EXISTS employees (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        age INTEGER,
        department TEXT
    )
''')

插入数据

cursor.execute(
    'INSERT INTO employees (name, age, department) VALUES (?, ?, ?)',
    ('John Doe', 30, 'Engineering')
)

这个 SQL 语句向 employees 表中插入了一行数据。? 符号作为占位符，用于防止 SQL 注入攻击。实际的参数作为第二个参数传递给 cursor.execute() 方法。

更新数据

cursor.execute(
    'UPDATE employees SET age = ? WHERE name = ?',
    (35, 'John Doe')
)

删除数据

cursor.execute(
    'DELETE FROM employees WHERE department = ?',
    ('Engineering',)
)

这个 SQL 语句删除了 employees 表中所有 department 为 Engineering 的记录。

查询数据

cursor.execute('SELECT * FROM employees')
rows = cursor.fetchall()
for row in rows:
    print(row)

这个 SQL 语句查询了 employees 表中的所有记录，并将结果存储在 rows 变量中。

参数化查询

使用参数化查询可以防止 SQL 注入攻击。在上面的插入、更新和删除数据的例子中，我们都使用了参数化查询。

注意

在执行修改数据的操作（如插入、更新、删除）后，你需要调用 conn.commit() 来确保更改被保存到数据库中。
在执行查询操作后，你可以使用 cursor.fetchall()、cursor.fetchone() 或者 cursor.executescript() 来获取查询结果。
确保在操作完成后关闭游标和数据库连接，以释放资源。

cursor.execute() 是与 SQLite 数据库交互的核心方法，通过它你可以实现对数据库的精确控制和操作。

cursor.fetchall()

cursor.fetchall() 是在Python中使用数据库API时的一个常用方法，特别是在与关系型数据库（如MySQL、PostgreSQL、SQLite等）交互时。这个方法属于数据库游标（cursor）对象，用于从数据库查询中检索所有（剩余的）行。

当你执行一个查询语句，比如 SELECT 语句，数据库会返回一个结果集，这个结果集可以通过游标对象来访问。使用 cursor.fetchall() 方法可以一次性获取这个结果集中的所有行，并将它们作为一个列表返回。每个列表元素都是一个代表查询结果一行的元组（tuple）。

封装实例：

# -*- coding: utf-8 -*-
import sqlite3

import random

class SqliteDB:

    def __init__(self, database="amz.db"):
        try:
            self.conn = sqlite3.connect(database)
            # 创建一个cursor：
            self.cursor = self.conn.cursor()
        except Exception as e:
            print(e)

    # 返回执行execute()方法后影响的行数
    def execute(self, sql):
        self.cursor.execute(sql)
        rowcount = self.cursor.rowcount
        return rowcount

    # 删除并返回影响行数
    def delete(self, **kwargs):
        table = kwargs['table']
        where = kwargs['where']
        whereStr = ""
        if where is not None:
            whereStr = where
        sql = f"delete from {table} where {whereStr};"
        try:
            # print(sql)
            # 执行SQL语句
            self.cursor.execute(sql)
            # 提交到数据库执行
            self.conn.commit()
        except:
            # 发生错误时回滚
            self.conn.rollback()
        return self.cursor.rowcount

    

    # 新增并返回新增ID
    def insert(self, **kwargs):
        table = kwargs['table']
        del kwargs['table']
        sql = 'insert into %s(' % table
        fields = ""
        values = ""
        for k, v in kwargs.items():
            fields += "%s," % k
            values += "'%s'," % v
        fields = fields.rstrip(',')
        values = values.rstrip(',')
        sql = sql + fields + ")values(" + values + ")"
        print(sql)
        res = []
        try:
            # 执行SQL语句
            self.cursor.execute(sql)
            # 提交到数据库执行
            self.conn.commit()
            # 获取自增id
            res = self.cursor.lastrowid
        except:
            # 发生错误时回滚
            self.conn.rollback()
        return res

    # 修改数据并返回影响的行数

    def update(self, **kwargs):
        table = kwargs['table']
        # del kwargs['table']
        kwargs.pop('table')
        where = kwargs['where']
        kwargs.pop('where')
        sql = 'update %s set ' % table
        for k, v in kwargs.items():
            sql += "%s='%s'," % (k, v)
        sql = sql.rstrip(',')
        sql += ' where %s' % where
        print(sql)
        rowcount = 0
        try:
            # 执行SQL语句
            self.cursor.execute(sql)
            # 提交到数据库执行
            self.conn.commit()
            # 影响的行数
            rowcount = self.cursor.rowcount
        except:
            # 发生错误时回滚
            self.conn.rollback()
        return rowcount

    # 查-一条条数据
    def getOne(self, **kwargs):
        table = kwargs['table']
        field = 'field' in kwargs and kwargs['field'] or '*'
        where = 'where' in kwargs and 'where ' + kwargs['where'] or ''
        order = 'order' in kwargs and 'order by ' + kwargs['order'] or ''
        sql = 'select %s from %s %s %s limit 1' % (field, table, where, order)
        print(sql)
        data = []
        try:
            # 执行SQL语句
            self.cursor.execute(sql)
            # 使用 fetchone() 方法获取单条数据.
            data = self.cursor.fetchall()[0]
        except:
            # 发生错误时回滚
            self.conn.rollback()
        return data

    # 查所有数据
    def getAll(self, **kwargs):
        table = kwargs['table']
        field = 'field' in kwargs and kwargs['field'] or '*'
        where = 'where' in kwargs and 'where ' + kwargs['where'] or ''
        order = 'order' in kwargs and 'order by ' + kwargs['order'] or ''
        sql = 'select %s from %s %s %s ' % (field, table, where, order)
        print(sql)
        try:
            # 执行SQL语句
            self.cursor.execute(sql)
            # 使用 fetchone() 方法获取单条数据.
            data = self.cursor.fetchall()
        except:
            # 发生错误时回滚
            self.conn.rollback()
        return list(data)


    def createtb(self, sql=None, table=None, drop=None):

        if table is None:
            print("table参数不能为空")
            return False

        # 强制清空
        if drop is not None:
            self.droptb(table)

        # 查看表格是否已经存在
        self.cursor.execute(f"SELECT COUNT(*) FROM sqlite_master where type='table' and name='{table}'")
        values = self.cursor.fetchall()
        existtb = values[0][0]

        if existtb == 0:
            # 执行一条SQL语句：创建user表 'CREATE TABLE user(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,name VARCHAR)'
            self.cursor.execute(sql)

        return self.cursor.rowcount

    def droptb(self, table=None):
        if table is None:
            print("表格不能为空")
            return False
        self.cursor.execute(f"drop table if exists {table};")
        return self.cursor.rowcount

    def __del__(self):
        self.conn.close()  # 关闭连接



if __name__ == '__main__':
    db = SqliteDB()
    sql = "CREATE TABLE asin (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, asin VARCHAR, status VARCHAR, title VARCHAR, cover VARCHAR, stars double, lreviewdate VARCHAR, description VARCHAR, url VARCHAR, atime timestamp NULL DEFAULT NULL, mtime timestamp NULL DEFAULT NULL, price double, flag INTEGER DEFAULT 0, reviewcount INTEGER DEFAULT 0)"
    # sql = "CREATE TABLE keyword (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, keyword VARCHAR, flag INTEGER DEFAULT 0, isrelate INTEGER DEFAULT 0, locked INTEGER DEFAULT 0, );"
    # sql = "CREATE TABLE pre_asin (id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, asin VARCHAR, status VARCHAR, title VARCHAR, cover VARCHAR, stars double, lreviewdate VARCHAR, description VARCHAR, url VARCHAR, atime timestamp NULL DEFAULT NULL, mtime timestamp NULL DEFAULT NULL, price double, flag INTEGER DEFAULT 0, reviewcount INTEGER DEFAULT 0)"
    res = db.createtb(sql=sql,table='asin')
    print(res)

    asin = ''
    for i in range(5):
        asin += random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

    # insert测试
    cs = db.insert(table="asin", asin=asin, title="标题"+str(random.randint(100,999)), stars=4.3)
    print(cs)

    #delete 测试
    cs = db.delete(table="asin", where="id=6")
    print(cs)

   # update 测试
    cs = db.update(table="asin", title="8888", stars=4.9, where="id=2")
    print(cs)

    #select 测试
    cs = db.getAll(table="asin", where="1")
    print(cs)

在Python中，**kwargs 是一个特殊的参数语法，用于函数定义中。它允许函数接收任意数量的关键字参数（keyword arguments），而不需要在函数定义中明确指定每个参数的名称。**kwargs 实际上是一个字典（dictionary），它包含了所有未被其他位置参数（positional arguments）或命名参数（named arguments）捕获的关键字参数。

当调用一个包含 **kwargs 的函数时，Python会将所有额外的关键字参数收集到一个字典中，并将这个字典赋值给 kwargs 变量。这意味着你可以通过 kwargs 访问所有的额外关键字参数。

例如，考虑以下函数定义：

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

如果你调用这个函数，像这样：

my_function(a=1, b=2, c=3)

函数内部的循环将会打印：

a: 1
b: 2
c: 3

这是因为 a、b 和 c 都是作为关键字参数传递给 my_function 的，而 **kwargs 捕获了这些参数，并将它们存储在一个字典中。

**kwargs 的使用场景通常包括：

当你不知道函数将会接收哪些额外的参数时。
当你想要提供一个函数，允许用户传递额外的参数，而这些参数可能在函数的不同调用中有所不同时。
当你想要动态地处理函数参数时。

**kwargs 提供了一种灵活的方式来定义可以接受任意数量关键字参数的函数，这在很多情况下非常有用。然而，也要注意，过度使用 **kwargs 可能会使函数的接口变得不够明确，降低代码的可读性和可维护性。因此，应当在适当的时候使用它，并确保函数的行为对于调用者来说是清晰的。

封装代码参考自：Loen lucoo01

豪豪学习8848

关注

12
点赞
踩
28

收藏

觉得还不错? 一键收藏
1
评论
python连接sqlite数据库

import sqlite3sqlite是一个非常流行的轻量级数据库，它不需要单独的服务器进程，数据库就是一些文件。使用sqlite3库，您可以执行SQL命令来创建数据库、表、插入数据、查询数据等。在Python中使用库与SQLite数据库交互时，方法是用来创建一个游标对象的。游标对象用于执行SQL语句，并提供操作数据库的接口。通过这个游标对象，你可以执行查询、更新、删除等操作，并且可以获取查询结果。在开篇例子中，创建了一个游标对象。通过这个游标对象，我们执行了几个SQL语句，包括创建表、插入数据和查询
复制链接

扫一扫