TinyDB - 快速指南

---

TinyDB - 简介

什么是TinyDB？

TinyDB采用纯Python编程语言编写，是一个小型、轻量级的文档型数据库，无外部依赖。它提供了简单的 API，使其易于使用。我们可以使用TinyDB数据库进行小型项目应用，无需任何配置。

TinyDB模块作为Python程序的第三方模块，可用于存储、检索和修改JSON格式的数据。

TinyDB的特点

TinyDB 是一个干净、自由的数据库，可以操作多种格式的文档。它具有以下特点。

• 非常小- TinyDB 数据库本质上非常小，只有 1800 行代码和 1600 行测试。

• 易于使用- TinyDB 因其简单干净的 API 而易于使用。

• 面向文档- 在TinyDB中，我们可以存储任何文档。该文档将表示为 dict。

• 独立- TinyDB 数据库独立于任何外部服务器和 PyPI 的外部依赖项。

• 与 Python 3.6 或最新版本兼容- TinyDB 经过测试并与 Python 3.6 及最新版本兼容。它也可以与 PyPY3 配合使用。

• 可扩展- TinDB 可以通过编写新存储或修改存储的Behave轻松扩展。

TinyDB的优点

TinyDB 为学生、用户和开发人员提供了各种好处。

• TinyDB是开源数据库，不需要任何外部配置。

• 它非常易于使用，用户可以毫不费力地处理文档。

• 它自动将文档存储在数据库中。

• TinyDB 对于需要安装一些数据的个人项目来说是理想的选择。

• 它适合那些会被 SQL 或外部数据库服务器等大型数据库淹没的小型应用程序。

• 它使用简单的命令行和查询来操作数据。

• 测试覆盖率为 100%，即无需解释。

TinyDB 的局限性

如果您需要，TinyDB 将不是您项目的正确选择 -

• 为表创建索引，

• 管理表之间的关系，

• 使用 HTTP 服务器，或者

• 从多个处理器访问。

与其他数据库的比较

下表重点介绍了 TinyDB 与 MySQL 和 Oracle 数据库的不同之处 -

TinyDB - 环境设置

TinyDB 设置的先决条件

要安装 TinyDB，您的系统中必须安装 Python 3.6 或更高版本。您可以访问链接www.python.org并选择适合您操作系统的最新版本，即 Windows 和 Linux/Unix。我们有一个关于 Python 的综合教程，您可以在www.tutorialspoint.com上参考

安装TinyDB

您可以通过三种不同的方式安装 TinyDB：使用 Pack Manager、从其源代码或从 GitHub。

使用包管理器

TinyDB 的最新发行版本可通过包管理器pip和conda获得。让我们检查一下如何使用它们来安装 TinyDB -

要使用pip安装 TinyDB ，您可以使用以下命令 -

pip install tinydb

要通过conda-forge安装 TinyDB ，您可以使用以下命令 -

conda install -c conda-forge tinydb

从源头

您还可以从源代码分发安装 TinyDB。转到链接https://pypi.org/project/tinydb/#files下载文件并从源代码构建它。

来自 GitHub

要使用 GitHub 安装 TinyDB，请获取最新的开发版本，解压文件，然后使用以下命令进行安装 -

pip install

设置 TinyDB

安装后，请使用以下步骤设置 TinyDB 数据库。

第 1 步：导入 TinyDB 及其查询

首先，我们需要导入 TinyDB 及其查询。使用以下命令 -

from tinydb import TinyDB, Query

第 2 步：创建文件

TinyDB 数据库可以存储多种格式的数据，例如 XML、JSON 等。我们将使用以下文件创建一个 JSON 文件 -

db = TinyDB('Leekha.json')

上面的命令将创建 TinyDB 类的实例并将文件 Leekha.Json 传递给它。这是我们的数据将被存储的文件。现在，TinyDB 数据库设置已准备就绪，您可以对其进行操作。现在我们可以插入数据并操作数据库中的值。

卸载TinyDB

如果您需要卸载 TinyDB，可以使用以下命令 -

pip uninstall tinydb

TinyDB - 插入数据

我们已经创建了 TinyDB 的实例，并将一个 JSON 文件传递​​给它，用于存储我们的数据。现在是时候将项目插入我们的数据库了。数据应采用 Python 字典的形式。

句法

要插入项目，您可以使用insert()方法，其语法如下 -

db.insert({'type1': 'value1', 'type2': 'value2', 'typeN': 'valueN'})

我们也可以先创建一个字典，然后使用 insert() 方法将数据插入到数据库中。

data_item = {'type1': 'value1', 'type2': 'value2', 'typeN': 'valueN' } db.insert(data_item)

运行上述命令后，insert()方法将返回新创建的对象的ID。而且，我们的 JSON 文件将如下所示 -

{"_default": {"1": {"type1": "value1", "type2": "value2", "typeN": "valueN"}}}

看上面的表条目：' default '是表的名称，' 1 '是新创建的对象的ID，值是我们刚刚插入的数据。

示例：插入单个项目

让我们借助示例来理解上述概念。假设我们有一个数据库，其中包含显示学号、姓名、分数、科目和地址的学生信息。以下是存储在数据库中的信息 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   }
]

在上面的数据库中，如果要插入新的学生记录（即单个项目），请使用以下命令 -

db.insert({
   'roll_number': 6,
   'st_name':'jim',
   'mark':300,
   'subject':'sql',
   'address':'pune'
})

它将返回新创建的对象的 ID -

6

让我们再输入一项记录-

db.insert({
   'roll_number': 7,
   'st_name':'karan',
   'mark':290,
   'subject':'NoSQL',
   'address':'chennai'
})

它将返回新创建的对象的 ID -

7

如果您想检查数据库中存储的项目，请使用all()方法，如下所示 -

db.all()

它将产生以下输出-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"jim",
      "mark":300,
      "subject":"sql",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"karan",
      "mark":290,
      "subject":"NoSQL",
      "address":"chennai"
   }
]

您可以观察到它在 JSON 文件中添加了两个新数据项。

示例：一次插入多个项目

您还可以在 TinyDB 数据库中一次插入多个项目。为此，您需要使用insert_multiple()方法。让我们看一个例子 -

items = [
   {'roll_number': 8, 'st_name': 'petter', 'address': 'mumbai'},
   {'roll_number': 9, 'st_name': 'sadhana', 'subject': 'SQL'}
]
db.insert_multiple(items)

现在，使用 all() 方法检查数据库中存储的项目，如下所示 -

db.all()

它将产生以下输出-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"oracle",
      "address":"benglore"
   },
   {
      "roll_number":6,
      "st_name":"jim",
      "mark":300,
      "subject":"sql",
      "address":"pune"
   },
   {
      "roll_number":7,
      "st_name":"karan",
      "mark":290,
      "subject":"NoSQL",
      "address":"chennai"
   },
   {
      "roll_number":8,
      "st_name":"petter",
      "address":"mumbai"
   },
   {
      "roll_number":9,
      "st_name":"sadhana",
      "subject":"SQL"
   }
]

您可以观察到它在 JSON 文件中添加了两个新数据项。您还可以在添加最后两项时跳过数据项中的一些键值（就像我们所做的那样）。我们跳过了“标记”和“地址”。

TinyDB - 检索数据

您可以通过多种方式从 TinyDB 数据库检索数据。但要使用这些方法，您首先需要创建 Query 类的实例，如下所示 -

from tinydb import Query
Student = Query()

这里，Student是数据库的名称。

让我们检查一下从 TinyDB 数据库检索信息的各种方法。

使用 Search() 方法检索数据

search() 方法，顾名思义，返回与我们提供的查询匹配的项目列表，否则它将返回一个空列表。

对于这个例子和其他例子，我们将使用以下学生数据库数据 -

[
   {
      "roll_number": 1,
      "st_name": "elen",
      "mark": 250,
      "subject": "TinyDB",
      "address": "delhi"
   },
   {
      "roll_number": 2,
      "st_name": "Ram",
      "mark": [
         250,
         280
      ],
      "subject": [
         "TinyDB",
         "MySQL"
      ],
      "address": "delhi"
   },
   {
      "roll_number": 3,
      "st_name": "kevin",
      "mark": [
         180,
         200
      ],
      "subject": [
         "oracle",
         "sql"
      ],
      "address": "keral"
   },
   {
      "roll_number": 4,
      "st_name": "lakan",
      "mark": 200,
      "subject": "MySQL",
      "address": "mumbai"
   },
   {
      "roll_number": 5,
      "st_name": "karan",
      "mark": 275,
      "subject": "TinyDB",
      "address": "benglore"
   }
]

让我们举个例子来理解 search() 方法 -

from tinydb import TinyDB, Query
db = TinyDB("leekha.json")
student = Query()
db.search(student.subject == 'TinyDB' )

上述查询将从学生数据库中检索以下输出-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

使用 get() 方法检索数据

与 search() 方法相反，get() 方法仅返回一个匹配文档。否则它将返回 None。例如，我们采用以下代码 -

from tinydb import TinyDB, Query
student = Query()
db.get(student.subject == 'TinyDB' )

上述查询将从学生数据库中检索以下数据。

[{'roll_number': 1, 'st_name': 'elen', 'mark': 250, 'subject': 'TinyDB', 'address': 'delhi'}]

使用 all() 方法检索数据

all ()方法返回数据库中的所有文档。例如，

db.all()

它将从学生数据库中检索整个数据。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

使用 for 循环检索数据

for 循环还返回数据库中的所有文档。例如，

for info in db:
   print(info)

就像 all() 方法一样，它将检索学生数据库中的所有行。

TinyDB - 更新数据

TinyDB可以存储多种格式的数据，我们可以使用各种方法轻松检索存储的数据。但有时，我们需要更新数据，为此我们可以使用update()方法。

为了更新数据库，我们首先需要创建Query类的实例。您可以使用以下命令来实现此目的 -

from tinydb import Query
Student = Query()

这里，Student是我们数据库的名称。

update() 方法

这是 update() 方法的语法 -

db.update({ updated field: updated information… }, stable field: information)

让我们通过一个例子来了解 update() 方法是如何工作的。对于这个例子，我们将使用以下学生数据库 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

根据给定的数据，roll_number为“1”的学生的名字是“elen”。以下查询会将学生姓名更新为“Adam” -

from tinydb import TinyDB, Query
student = Query()
db.update({'st_name' : 'Adam'}, student.roll_number == 1 )

它将返回更新后的对象的 id -

[1]

现在，您可以使用 all() 方法来查看更新的数据库 -

db.all()

它将显示更新的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

有时，我们需要更新数据库中所有文档的一个或多个字段。为此，我们可以直接使用update()方法，不需要编写查询参数。以下查询会将所有学生的地址更改为“College_Hostel” -

db.update({'address': 'College_Hostel'})

它将返回更新后的对象的 id -

[1,2,3,4,5]

同样，您可以使用 all() 方法来查看更新的数据库。

db.all()

它将显示更新的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"College_Hostel"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":" College_Hostel "
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":" College_Hostel "
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":" College_Hostel "
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":" College_Hostel "
   }
]

观察所有行的地址字段具有相同的数据，即“College_Hostel”。

TinyDB - 删除数据

如果您需要从 TinyDB 数据库中永久删除一组特定数据，可以使用remove()方法来实现。与检索和更新数据一样，您首先需要创建Query类的实例来删除数据。您可以使用以下命令来实现此目的 -

from tinydb import Query
Student = Query()

这里，Student是我们数据库的名称。

移除()方法

这是remove()方法的语法 -

db.remove( Query() field regex )

remove() 方法接受可选条件以及可选的文档 ID 列表。

学生数据库

我们将使用以下学生数据库作为本章的示例。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例：删除单行数据

让我们通过一个例子来理解remove()方法。

from tinydb import TinyDB, Query
student = Query()
db.remove(student.roll_number == 5)

上面的查询将删除学生学号为 5 的数据。它将返回被删除对象的 ID -

[5]

现在，我们可以使用 all() 方法来查看更新后的数据库。

db.all()

它将显示更新数据库中的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   }
]

示例：删除多行数据

如果您想一次删除多行，可以使用remove()方法，如下所示：

from tinydb import TinyDB, Query
student = Query()
db.remove(student.roll_number > 2)

它将返回已删除对象的 ID：

[3,4]

使用 all() 方法查看更新的数据库。

db.all()

它将显示更新数据库中的数据 -

[
   {
      "roll_number":1,
      "st_name":"Adam",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

示例：删除整个数据

如果要从数据库中删除所有数据，可以使用truncate()方法，如下所示 -

db.truncate()

接下来，使用 all() 方法查看更新的数据库。

db.all()

它将显示一个空数据库作为输出-

[]

TinyDB - 查询

TinyDB 拥有丰富的查询集。我们有多种方法来构造查询：第一种方法类似于 ORM 工具的语法，第二种方法是使用“Where”子句的传统方法。

在本章中，我们将了解在 TinyDB 数据库中构造查询的两种方法。

第一种方法：导入查询

第一种方法类似于 ORM 工具的语法，首先我们需要在命令提示符中导入查询。导入后，我们就可以使用查询对象来操作TinyDB数据库了。语法如下-

from tinydb import Query
student = Query()

这里，“student”是我们数据库的名称。对于示例，我们将使用以下学生数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

例子

以下是从学生数据库中检索数据的查询，其中学生的roll_no小于 3 -

>>> db.search(Query().roll_number < 3)

或者，

>>> student = Query()
>>> db.search(student.roll_number < 3)

上述搜索查询将产生以下结果 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

有时文件名不是有效的 Python 标识符。在这种情况下，我们将无法访问该字段。对于这种情况，我们需要切换到字典访问表示法，如下所示 -

student = Query();

# Invalid Python syntax
db.search(student.security-code == 'ABCD')

# Use the following dict access notation
db.search(student['security-code'] == 'ABCD')

第二种方法：使用“where”子句

第二种方法是使用“where”子句构建查询的传统方法。语法如下-

from tinydb import where
db.search(where('field') == 'value')

例子

TinyDB主题字段的“ where ”子句-

db.search(where('subject') == 'MySQL') 

上述查询将产生以下输出-

[{
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
}]

TinyDB - 搜索

TinyDB 提供了search()方法来帮助您从文档中搜索任何数据。与query()对象一起，search() 方法可用于查找 JSON 文件中的数据。我们可以通过多种方式在 TinyDB 数据库上使用 search() 方法。

方法 1：TinyDB search() 与字段的存在性

我们可以根据字段的存在性从数据库中搜索数据。让我们通过一个例子来理解它。对于此示例和其他示例，我们将使用以下学生数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

例子

基于字段是否存在的搜索查询如下 -

from tinydb import Query
student = Query()
db.search(student.address.exists())

上述查询将从学生文件中检索以下数据-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

方法2：使用正则表达式的TinyDB search()

我们可以使用正则表达式（Regex）从数据库中搜索特定数据。让我们通过几个例子来了解它是如何工作的。

实施例1

与正则表达式匹配的完整项目搜索 -

from tinydb import Query
student = Query()
db.search(student.st_name.matches('[aZ]*'))

该查询将产生以下输出-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

示例2

使用正则表达式区分大小写的搜索 -

from tinydb import Query
import re
student = Query()
db.search(student.st_name.matches('lakan', flags=re.IGNORECASE))

它将产生以下输出-

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

实施例3

与正则表达式匹配的项目的任何部分 -

from tinydb import Query
student = Query()
db.search(student.st_name.search('r+'))

该查询将产生以下输出-

[{
   'roll_number': 5,
   'st_name': 'karan',
   'mark': 275,
   'subject': 'TinyDB',
   'address': 'benglore'
}]

方法 3：使用子字符串的 TinyDB search()

我们还可以在从 TinyDB 数据库中搜索特定数据时使用子字符串。让我们通过几个例子来了解它是如何工作的 -

示例1

看看这个查询；它将获取“地址”字段为“delhi”的所有行。

from tinydb import Query
student = Query()
db.search(student['address'] == 'delhi')

它将产生以下输出-

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

示例2

在此查询中，我们对 search() 方法使用了稍微不同的语法。

from tinydb import Query
student = Query()
db.search(student.address.search('mumbai'))

它将获取“地址”字段为“孟买”的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

TinyDB - where 子句

TinyDB 提供了“where”子句，您可以在搜索特定数据时使用它。“where”子句有助于过滤掉不需要的数据。借助“where”子句，您可以快速访问特定数据。

在使用“where”子句之前，我们需要先导入它。“where”子句的语法如下-

from tinydb import where
db.search(where('field') == 'value')

让我们借助几个示例来了解“where”子句的用法。

学生数据库

对于示例，我们将使用以下学生数据库。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

实施例1

让我们对主题字段使用“ where ”子句-

db.search(where('subject') == 'MySQL')

此查询将获取“主题”字段为“MySQL”的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakan',
   'mark': 200, 
   'subject': 'MySQL',
   'address': 'mumbai'
}]

实施例2

让我们看看“ where ”子句与“不等于”条件的另一种用法 -

db.search(where('mark') != 275)

此查询将获取“mark”字段不等于“275”的所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   }
]

TinyDB -exists() 查询

TinyDB 提供了一个名为exists()的高级查询，用于检查JSON 文件中数据是否存在。contains ()查询实际上测试 JSON 文件中子字段数据的可用性。contains() 查询基于布尔条件进行工作。如果子字段存在（即BOOLEAN TRUE），它将从JSON文件中获取相应的数据，否则将返回空白值。

句法

TinyDB contains() 的语法如下 -

db.search(Query().field.exists())

这里，字段代表我们想要访问的数据部分。Query()是从 JSON 表Student创建的对象。

我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们对名为“ subject ”的字段使用 TinyDB contains()查询-

db.search(student.subject.exists())

此查询将获取所有行，因为所有行都有“主题”字段 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":" TinyDB ",
      "address":"benglore"
   }
]

实施例2

现在让我们对“地址”字段使用exists()查询-

db.search(student.address.exists())

它将获取以下行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":" TinyDB ",
      "address":"benglore"
   }
]

实施例3

现在，让我们尝试使用exists()查询不可用的字段 -

db.search(student.city.exists())

由于给定表中没有任何行具有名为“city”的字段，因此上面的 contains() 查询将返回空白值 -

[]

TinyDB - matches() 查询

matches() 查询将 JSON 文件中的数据与给定条件（以正则表达式的形式）进行匹配，并相应地返回结果。如果条件与文件中的数据不匹配，它将返回空白值。

句法

TinyDB matches()的语法如下 -

db.search(Query().field.matches(regular expression))

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。

让我们通过几个示例来了解它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看如何使用matches()进行完整项目搜索。

from tinydb import Query
student = Query()
db.search(student.st_name.matches('[aZ]*'))

此查询将获取所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

实施例2

让我们看看如何使用 matches() 进行区分大小写的搜索。

from tinydb import Query
import re
student = Query()
db.search(student.st_name.matches('ram', flags=re.IGNORECASE))

此查询将获取学生姓名与字符串“ram”匹配的行。请注意，我们在匹配字符串时使用了一个标志来忽略大小写。

[{
   'roll_number': 2,
   'st_name': 'Ram',
   'mark': [250, 280],
   'subject': ['TinyDB', 'MySQL'],
   'address': 'delhi'
}]

实施例3

让我们看看如何对特定项目使用 matches()。

student = Query()
db.search(student.address.matches('keral'))

此查询将获取地址与字符串“keral”匹配的行。

[{'roll_number': 3, 'st_name': 'kevin', 'mark': [180, 200], 'subject':
['oracle', 'sql'], 'address': 'keral'}]

实施例4

让我们看看当没有找到特定项目时 matches() 会返回什么 -

student = Query()
db.search(student.address.matches('Ratlam'))

没有“地址”字段与字符串“Ratlam”匹配的行，因此它将返回空白值 -

[]

TinyDB - test() 查询

test ()查询将测试给定的参数是否与表中的数据匹配。如果与数据匹配，则返回匹配的数据，否则返回空白。首先，我们需要定义一个测试函数及其参数，然后它将在给定数据库中搜索该项目。

句法

TinyDB test()的语法如下 -

db.search(Query().field.test(function or condition, *arguments))

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。

我们可以创建一个自定义测试函数，如下所示 -

object = lambda t: t == 'value'

这里，lamba关键字对于创建自定义测试函数非常重要。

让我们通过几个示例来了解它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

我们将首先创建一个测试函数，然后在我们的学生表中使用它 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
objects = lambda t: t == [250, 280]
db.search(Query().mark.test(objects))

它将获取“mark”字段值为 [250, 280] 的行 -

[{'roll_number': 2, 'st_name': 'Ram', 'mark': [250, 280], 'subject':
['TinyDB', 'MySQL'], 'address': 'delhi'}]

实施例2

在此示例中，我们将在测试函数中使用“主题”字段 -

student = Query()
db = TinyDB('student.json')
objects = lambda t: t == 'TinyDB'
db.search(student.subject.test(objects))

此查询将获取“subject”字段值为“TinyDB”的所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - any() 查询

为了搜索包含列表的字段，TinyDB 提供了一个名为any()的方法。此方法至少匹配数据库中的一个给定值。它根据提供的查询找到整个列表或最小一个值。

句法

TinyDB any ()的语法如下 -

db.search(Query().field.any(query|list)

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。

• 如果我们提供查询作为any()方法的参数，它将匹配列表字段中至少有一个文档与给定查询匹配的所有文档。

• 另一方面，如果我们提供list作为any()方法的参数，它将匹配给定列表中至少存在列表字段中的一个文档的所有文档。

让我们通过几个示例来了解它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看如何从学生表中找到主题为 TinyDB、MySQL、SQL 或任意两个或三个的组合的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['TinyDB', 'MySQL', 'oracle']))

上面的查询将获取“subject”字段包含以下任何值的所有行：“TinyDB”、“MySQL”或“oracle” -

[
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   }
]

实施例2

让我们看看any()方法在与给定列表中的任何内容都不匹配时如何反应 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['Oracle']))

此查询将返回空白值，因为没有“主题”为“Oracle”的行。

[]

实施例3

请注意它区分大小写。“主题”字段没有“ Oracle ”，但有“ oracle ”。尝试以下查询 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.any(['oracle']))

它将获取以下行 -

[{
   'roll_number': 3,
   'st_name': 'kevin',
   'mark': [180, 200],
   'subject': ['oracle', 'sql'],
   'address': 'keral'
}]

由于它区分大小写，因此在上一个示例中返回空白值，因为没有“主题”为“Oracle”的行。

TinyDB - all() 查询

TinyDB 提供了一个名为all()的方法，该方法根据提供的查询查找整个值列表。让我们举一个例子来了解它是如何工作的。

句法

TinyDB all()的语法如下 -

db.search(Query().field.all(query|list)

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。

• 如果我们提供一个查询作为all()方法的参数，它将匹配列表字段中的所有文档与给定查询匹配的所有文档。

• 另一方面，如果我们提供一个列表作为all()方法的参数，它将匹配列表字段中的所有文档都出现在给定列表中的所有文档。

让我们通过几个示例来了解它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看如何从学生表中找到主题为 TinyDB 和 MySQL 的字段 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.all(['TinyDB', 'MySQL']))

此查询将获取以下行 -

[{
   'roll_number': 2,
   'st_name': 'Ram',
   'mark': [250, 280],
   'subject': ['TinyDB', 'MySQL'],
   'address': 'delhi'
}]

实施例2

让我们看看如何使用all()从数据库中获取整个数据 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.all()

它将从链接数据库中获取所有行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - one_of() 查询

为了匹配子字段数据，TinyDB 提供了一个名为one_of()的方法。此方法搜索单个类别并获得至少一个相似值。如果该字段包含在提供的列表中，它将匹配。

句法

TinyDB one_of()的语法如下 -

db.search(Query().field.one_of(list)

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。它将获取一个类别的单个或多个值。

让我们通过几个示例来了解它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看如何从学生表中找到地址为“delhi”或“pune”的字段-

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().address.one_of(['delhi', 'pune']))

它将获取“地址”字段包含“delhi”或“pune”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   }
]

实施例2

让我们看另一个带有“主题”字段的示例 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(Query().subject.one_of(['TinyDB', 'MySQL']))

它将获取“主题”字段包含“TinyDB”或“MySQL”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - 逻辑否定

逻辑非用作逆逻辑门。它将匹配与给定查询不匹配的文档。简单来说，它将显示给定命令的相反含义。

句法

TinyDB逻辑取反的语法如下 -

db.search(~(Query().field)

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。它将获取代表给定命令相反含义的数据。

让我们举几个例子，看看它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看如何从学生表中找到学生姓名不为“ elen ”的字段-

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(~(Query().st_name == 'elen'))

上面的查询将获取学生姓名不是“elen”的所有行。

[
   {
      "roll_number":2,
      "st_name":"Ram",
      "mark":[
         250,
         280
      ],
      "subject":[
         "TinyDB",
         "MySQL"
      ],
      "address":"delhi"
   },
   {
      "roll_number":3,
      "st_name":"kevin",
      "mark":[
         180,
         200
      ],
      "subject":[
         "oracle",
         "sql"
      ],
      "address":"keral"
   },
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

实施例2

让我们看看如何使用逻辑非来避免特定地址 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search(~(student.address.one_of(['keral', 'delhi'])))

此查询将获取“address”字段不包含“keral”或“delhi”的所有行。

[
   {
      "roll_number":4,
      "st_name":"lakan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

TinyDB - 逻辑与

“逻辑与”运算符组合多个条件，如果满足所有条件，则计算结果为 True。TinyDB 逻辑 AND 对数据库的两个查询进行操作。如果两个查询都为 True，TinyDB 将获取所需的数据。另一方面，如果任何一个查询为 False，它将返回空白。

句法

TinyDB逻辑 AND的语法如下 -

db.search((Query().(query1) & (Query().(query2) 

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。如果两个条件都满足，它将获取数据，否则将返回空白。

让我们举几个例子来看看逻辑与是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看当我们在“st_name=lakhan”和“subject=MYSQL”字段上应用逻辑 AND 时，TinyDB Student 数据库会返回什么 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search ((Query().st_name == 'lakhan') & (Query().subject == 'MySQL'))

此查询将仅获取学生姓名为“lakhan”且“主题”为“MySQL”的行。

[{
   'roll_number': 4,
   'st_name': 'lakhan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

实施例2

在此示例中，让我们在“subject”和“roll_number”字段上应用逻辑 AND -

from tinydb import TinyDB, Query
student = Query()
db = TinyDB('student.json')
db.search((student.subject.search('M')) & (student.roll_number < 5))

此查询将获取 roll_number 小于“4”且“subject”以字母“M”开头的所有行。

[{
   'roll_number': 4,
   'st_name': 'lakhan',
   'mark': 200,
   'subject': 'MySQL',
   'address': 'mumbai'
}]

TinyDB - 逻辑或

“逻辑或”运算符组合多个条件，并且仅当满足其中一个条件时才计算结果为 True。TinyDB 逻辑 OR 对数据库的两个查询进行操作。如果任何一个查询为 True，TinyDB 将获取所需的数据。另一方面，如果两个查询都为 False，则返回空白。

句法

TinyDB逻辑或的语法如下 -

db.search((Query().(query1) | (Query().(query2) 

这里，字段代表我们想要访问的数据部分。Query()是我们名为Student 的JSON 表创建的对象。如果满足任何一个条件，它将获取数据，否则将返回空白。

让我们举几个例子，看看它是如何工作的。我们将使用前面所有章节中使用的相同学生数据库。

实施例1

让我们看看当我们对“st_name”和“subject”字段应用逻辑或并检查以下条件时，TinyDB Student 数据库会返回什么：“st_name=lakhan”和“subject=TinyDB” -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search ((Query().st_name == 'lakan') | (Query().subject == 'TinyDB')) 

此查询将获取以下行 -

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },
   {
      "roll_number":4,
      "st_name":"lakhan",
      "mark":200,
      "subject":"MySQL",
      "address":"mumbai"
   },
   {
      "roll_number":5,
      "st_name":"karan",
      "mark":275,
      "subject":"TinyDB",
      "address":"benglore"
   }
]

实施例2

在此示例中，让我们对“subject”和“roll_number”字段应用逻辑或 -

from tinydb import TinyDB, Query
db = TinyDB('student.json')
db.search((student.subject.search('M')) | (student.roll_number < 5))

此查询将获取“主题”字段以字母“M”开头或“roll_number”小于“5”的所有行。

[
   {
      "roll_number":1,
      "st_name":"elen",
      "mark":250,
      "subject":"TinyDB",
      "address":"delhi"
   },