devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python连接sqlite数据库_python 连接sqlite

作者：小舞很执着 | 2024-07-27 19:26:03

赞

踩

python 连接sqlite
  1. import sqlite3
  2.  
  3. # 连接到SQLite数据库
  4. # 如果数据库文件不存在，会自动在当前目录创建:
  5. conn = sqlite3.connect('example.db')
  6.  
  7. try:
  8.     # 创建一个Cursor对象
  9.     cursor = conn.cursor()
  10.  
  11.     # 创建一个新表
  12.     cursor.execute('''
  13.         CREATE TABLE IF NOT EXISTS users (
  14.             id INTEGER PRIMARY KEY,
  15.             name TEXT NOT NULL,
  16.             age INTEGER
  17.         );
  18.     ''')
  19.  
  20.     # 插入一些数据
  21.     cursor.execute("INSERT INTO users (name, age) VALUES ('Alice', 25)")
  22.     cursor.execute("INSERT INTO users (name, age) VALUES ('Bob', 30)")
  23.  
  24.     # 提交更改到数据库
  25.     conn.commit()
  26.  
  27.     # 如果需要查询数据，可以取消注释下面的代码
  28.     # cursor.execute("SELECT * FROM users")
  29.     # rows = cursor.fetchall()
  30.     # for row in rows:
  31.     #     print(row)
  32.  
  33. except sqlite3.Error as e:
  34.     # 如果发生错误，则打印错误信息
  35.     print(e)
  36.  
  37. finally:
  38.     # 关闭Cursor和数据库连接
  39.     if conn:
  40.         cursor.close()
  41.         conn.close()
  42.  
  43. # 程序结束
'
运行

import sqlite3

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

.cursor()

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

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

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

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

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

cursor.execute()

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

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

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

创建表

  1. cursor.execute('''
  2.     CREATE TABLE IF NOT EXISTS employees (
  3.         id INTEGER PRIMARY KEY,
  4.         name TEXT NOT NULL,
  5.         age INTEGER,
  6.         department TEXT
  7.     )
  8. ''')

插入数据

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

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

更新数据

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

删除数据

  1. cursor.execute(
  2.     'DELETE FROM employees WHERE department = ?',
  3.     ('Engineering',)
  4. )

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

查询数据

  1. cursor.execute('SELECT * FROM employees')
  2. rows = cursor.fetchall()
  3. for row in rows:
  4.     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）。

封装实例：

  1. # -*- coding: utf-8 -*-
  2. import sqlite3
  3.  
  4. import random
  5.  
  6. class SqliteDB:
  7.  
  8.     def __init__(self, database="amz.db"):
  9.         try:
  10.             self.conn = sqlite3.connect(database)
  11.             # 创建一个cursor：
  12.             self.cursor = self.conn.cursor()
  13.         except Exception as e:
  14.             print(e)
  15.  
  16.     # 返回执行execute()方法后影响的行数
  17.     def execute(self, sql):
  18.         self.cursor.execute(sql)
  19.         rowcount = self.cursor.rowcount
  20.         return rowcount
  21.  
  22.     # 删除并返回影响行数
  23.     def delete(self, **kwargs):
  24.         table = kwargs['table']
  25.         where = kwargs['where']
  26.         whereStr = ""
  27.         if where is not None:
  28.             whereStr = where
  29.         sql = f"delete from {table} where {whereStr};"
  30.         try:
  31.             # print(sql)
  32.             # 执行SQL语句
  33.             self.cursor.execute(sql)
  34.             # 提交到数据库执行
  35.             self.conn.commit()
  36.         except:
  37.             # 发生错误时回滚
  38.             self.conn.rollback()
  39.         return self.cursor.rowcount
  40.  
  41.     
  42.  
  43.     # 新增并返回新增ID
  44.     def insert(self, **kwargs):
  45.         table = kwargs['table']
  46.         del kwargs['table']
  47.         sql = 'insert into %s(' % table
  48.         fields = ""
  49.         values = ""
  50.         for k, v in kwargs.items():
  51.             fields += "%s," % k
  52.             values += "'%s'," % v
  53.         fields = fields.rstrip(',')
  54.         values = values.rstrip(',')
  55.         sql = sql + fields + ")values(" + values + ")"
  56.         print(sql)
  57.         res = []
  58.         try:
  59.             # 执行SQL语句
  60.             self.cursor.execute(sql)
  61.             # 提交到数据库执行
  62.             self.conn.commit()
  63.             # 获取自增id
  64.             res = self.cursor.lastrowid
  65.         except:
  66.             # 发生错误时回滚
  67.             self.conn.rollback()
  68.         return res
  69.  
  70.     # 修改数据并返回影响的行数
  71.  
  72.     def update(self, **kwargs):
  73.         table = kwargs['table']
  74.         # del kwargs['table']
  75.         kwargs.pop('table')
  76.         where = kwargs['where']
  77.         kwargs.pop('where')
  78.         sql = 'update %s set ' % table
  79.         for k, v in kwargs.items():
  80.             sql += "%s='%s'," % (k, v)
  81.         sql = sql.rstrip(',')
  82.         sql += ' where %s' % where
  83.         print(sql)
  84.         rowcount = 0
  85.         try:
  86.             # 执行SQL语句
  87.             self.cursor.execute(sql)
  88.             # 提交到数据库执行
  89.             self.conn.commit()
  90.             # 影响的行数
  91.             rowcount = self.cursor.rowcount
  92.         except:
  93.             # 发生错误时回滚
  94.             self.conn.rollback()
  95.         return rowcount
  96.  
  97.     # 查-一条条数据
  98.     def getOne(self, **kwargs):
  99.         table = kwargs['table']
  100.         field = 'field' in kwargs and kwargs['field'] or '*'
  101.         where = 'where' in kwargs and 'where ' + kwargs['where'] or ''
  102.         order = 'order' in kwargs and 'order by ' + kwargs['order'] or ''
  103.         sql = 'select %s from %s %s %s limit 1' % (field, table, where, order)
  104.         print(sql)
  105.         data = []
  106.         try:
  107.             # 执行SQL语句
  108.             self.cursor.execute(sql)
  109.             # 使用 fetchone() 方法获取单条数据.
  110.             data = self.cursor.fetchall()[0]
  111.         except:
  112.             # 发生错误时回滚
  113.             self.conn.rollback()
  114.         return data
  115.  
  116.     # 查所有数据
  117.     def getAll(self, **kwargs):
  118.         table = kwargs['table']
  119.         field = 'field' in kwargs and kwargs['field'] or '*'
  120.         where = 'where' in kwargs and 'where ' + kwargs['where'] or ''
  121.         order = 'order' in kwargs and 'order by ' + kwargs['order'] or ''
  122.         sql = 'select %s from %s %s %s ' % (field, table, where, order)
  123.         print(sql)
  124.         try:
  125.             # 执行SQL语句
  126.             self.cursor.execute(sql)
  127.             # 使用 fetchone() 方法获取单条数据.
  128.             data = self.cursor.fetchall()
  129.         except:
  130.             # 发生错误时回滚
  131.             self.conn.rollback()
  132.         return list(data)
  133.  
  134.  
  135.     def createtb(self, sql=None, table=None, drop=None):
  136.  
  137.         if table is None:
  138.             print("table参数不能为空")
  139.             return False
  140.  
  141.         # 强制清空
  142.         if drop is not None:
  143.             self.droptb(table)
  144.  
  145.         # 查看表格是否已经存在
  146.         self.cursor.execute(f"SELECT COUNT(*) FROM sqlite_master where type='table' and name='{table}'")
  147.         values = self.cursor.fetchall()
  148.         existtb = values[0][0]
  149.  
  150.         if existtb == 0:
  151.             # 执行一条SQL语句：创建user表 'CREATE TABLE user(id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,name VARCHAR)'
  152.             self.cursor.execute(sql)
  153.  
  154.         return self.cursor.rowcount
  155.  
  156.     def droptb(self, table=None):
  157.         if table is None:
  158.             print("表格不能为空")
  159.             return False
  160.         self.cursor.execute(f"drop table if exists {table};")
  161.         return self.cursor.rowcount
  162.  
  163.     def __del__(self):
  164.         self.conn.close()  # 关闭连接
  165.  
  166.  
  167.  
  168. if __name__ == '__main__':
  169.     db = SqliteDB()
  170.     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)"
  171.     # 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, );"
  172.     # 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)"
  173.     res = db.createtb(sql=sql,table='asin')
  174.     print(res)
  175.  
  176.     asin = ''
  177.     for i in range(5):
  178.         asin += random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
  179.  
  180.     # insert测试
  181.     cs = db.insert(table="asin", asin=asin, title="标题"+str(random.randint(100,999)), stars=4.3)
  182.     print(cs)
  183.  
  184.     #delete 测试
  185.     cs = db.delete(table="asin", where="id=6")
  186.     print(cs)
  187.  
  188.    # update 测试
  189.     cs = db.update(table="asin", title="8888", stars=4.9, where="id=2")
  190.     print(cs)
  191.  
  192.     #select 测试
  193.     cs = db.getAll(table="asin", where="1")
  194.     print(cs)
  195.

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

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

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

  1. def my_function(**kwargs):
  2.     for key, value in kwargs.items():
  3.         print(f"{key}: {value}")
'
运行

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

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

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

  1. a: 1
  2. b: 2
  3. c: 3

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

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

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

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

封装代码参考自：Loen lucoo01

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/891454
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号