掌握 ElasticSearch 组合查询：Bool Query 详解与实践

news2025/2/24 9:18:40

掌握 ElasticSearch 组合查询：Bool Query 详解与实践

    • 一、引言 (Introduction)
    • 二、Bool 查询基础
      • 2.1 什么是 Bool 查询？
      • 2.2 Bool 查询的四种子句
      • 2.3 语法结构
    • 三、Bool 查询的四种子句详解与示例
      • 3.1 `must` 子句
      • 3.2 `filter` 子句
      • 3.3 `should` 子句
      • 3.4 `must_not` 子句
    • 四、`minimum_should_match` 参数
      • 4.1 什么是 `minimum_should_match`？
      • 4.2 默认值规则
      • 4.3 使用示例
      • 4.4 注意事项
    • 五、嵌套 Bool 查询
      • 5.1 什么是嵌套 Bool 查询？
      • 5.2 使用场景
      • 5.3 示例
    • 六、Bool 查询与相关性得分
      • 6.1 Bool 查询如何影响得分？
      • 6.2 调整子句的权重
    • 八、总结

一、引言 (Introduction)

在信息检索和数据分析的场景中，我们经常需要面对复杂的查询需求。简单的关键词搜索可能无法满足我们的要求，我们需要更精细的控制，例如：

  • 查找 同时 满足多个条件的文档（例如，既包含 “Elasticsearch” 又包含 “tutorial” 的文章）。
  • 过滤 出符合特定条件的文档（例如，只查看最近一周内发布的文章）。
  • 排除 满足特定条件的文档（例如，不显示已下架的商品）。
  • 对搜索结果进行 优先级排序（例如，优先显示标题中包含关键词的文章）。

为了应对这些复杂的查询需求，Elasticsearch 提供了 bool 查询。bool 查询就像一个强大的工具箱，它允许你将多个查询条件组合在一起，形成更复杂的查询逻辑。你可以将 bool 查询看作是乐高积木，通过组合不同的积木块（查询子句），你可以搭建出各种各样的结构（查询逻辑）。

本文将深入探讨 Elasticsearch 7.10 版本中的 bool 查询。你将学习到：

  • bool 查询的基本概念和工作原理。
  • bool 查询的四种核心子句：must、filter、should、must_not。
  • 如何使用 minimum_should_match 参数控制 should 子句的行为。
  • 如何嵌套 bool 查询，构建更复杂的查询逻辑。
  • bool 查询如何影响文档的相关性得分。
  • 通过实战案例学习如何在实际应用中运用 bool 查询。

二、Bool 查询基础

2.1 什么是 Bool 查询？

bool 查询是 Elasticsearch 中一种复合查询（compound query），它允许你将多个查询子句（query clause）组合在一起。这些子句可以是任何类型的查询，例如 match、term、range 等，甚至是另一个 bool 查询（嵌套）。

bool 查询的核心思想是 “more_matches_is_better”，也就是说，文档匹配的子句越多，它的相关性得分（_score）就越高。这使得 bool 查询非常适合用于构建复杂的查询逻辑，同时兼顾查询结果的相关性排序。

为了帮助你更好地理解 bool 查询，我们可以将其类比为编程语言中的逻辑运算符：

  • must 类似于逻辑与 (AND)：要求所有条件都必须满足。
  • filter也类似于逻辑与（AND）：要求所有条件都必须满足。
  • should 类似于逻辑或 (OR)：至少有一个条件满足即可。
  • must_not 类似于逻辑非 (NOT)：要求所有条件都不满足。

2.2 Bool 查询的四种子句

bool 查询包含四种核心子句，每种子句都有不同的作用和对得分的影响：

子句作用对得分的影响
must必须匹配。文档必须满足 must 子句中的所有条件。匹配的 must 子句越多，文档得分越高。
filter必须匹配（过滤器上下文）。文档必须满足 filter 子句中的所有条件。不影响得分。
should可以匹配。文档应该满足 should 子句中的一个或多个条件。匹配的 should 子句越多，文档得分越高。
must_not必须不匹配（过滤器上下文）。文档必须不满足 must_not 子句中的所有条件。不影响得分。

导出到 Google 表格

要点：

  • must 和 filter 子句都要求文档必须匹配，但 filter 子句不参与得分计算，因此通常比 must 子句更高效。
  • should 子句是可选的，但匹配 should 子句会提高文档的得分。
  • must_not 子句用于排除文档，它也不参与得分计算。
  • filter 和 must_not 子句处于_过滤器上下文_中，这意味着它们不计算得分，并且 Elasticsearch 会自动缓存这些子句的结果，以提高后续查询的性能。

2.3 语法结构

bool 查询的基本语法结构如下：

GET /_search
{
  "query": {
    "bool" : {
      "must" : [
        { /* 查询 1 */ },
        { /* 查询 2 */ }
      ],
      "filter": [
        { /* 过滤条件 1 */ },
        { /* 过滤条件 2 */ }
      ],
      "should" : [
        { /* 查询 3 */ },
        { /* 查询 4 */ }
      ],
      "must_not" : [
        { /* 排除条件 1 */ },
        { /* 排除条件 2 */ }
      ]
    }
  }
}

解释：

  • query: 这是 ElasticSearch 查询 DSL 的根元素。
  • bool: 表示这是一个 bool 查询。
  • must、filter、should、must_not: 这是 bool 查询的四种子句，每个子句都可以包含一个或多个查询条件（可以是任何类型的查询，例如 match、term、range 等）。

三、Bool 查询的四种子句详解与示例

接下来，我们将深入探讨 must、filter、should 和 must_not 四种子句的用法，并通过示例演示如何在实际场景中应用它们。

数据准备：

首先，我们创建一个名为 articles 的索引，并添加一些示例数据。我们将使用这些数据来演示 bool 查询的各种用法。

PUT articles
{
  "mappings": {
    "properties": {
      "title": { "type": "text" },
      "content": { "type": "text" },
      "category": { "type": "keyword" },
      "status": { "type": "keyword" },
      "author_id": { "type": "keyword" },
      "is_featured": { "type": "boolean" },
      "discount": { "type": "double" },
      "created_at": { "type": "date" },
      "out_of_stock":{ "type":"boolean"}
    }
  }
}

POST articles/_bulk
{"index":{"_index": "articles"}}
{"title": "Elasticsearch Tutorial for Beginners", "content": "This tutorial covers the basics of Elasticsearch.", "category": "technology", "status": "published", "author_id": "123", "is_featured": true, "discount": 0.0, "created_at": "2023-10-26", "out_of_stock": false}
{"index":{"_index": "articles"}}
{"title": "Advanced Logstash Techniques", "content": "Learn advanced techniques for processing logs with Logstash.", "category": "technology", "status": "published", "author_id": "456", "is_featured": false, "discount": 10.0, "created_at": "2023-10-27", "out_of_stock": false}
{"index":{"_index": "articles"}}
{"title": "Introduction to Kibana", "content": "Visualize your Elasticsearch data with Kibana.", "category": "technology", "status": "draft", "author_id": "123", "is_featured": false, "discount": 0.0, "created_at": "2023-10-28", "out_of_stock": false}
{"index":{"_index": "articles"}}
{"title": "Elasticsearch and Logstash Integration", "content": "Integrate Elasticsearch and Logstash for log management.", "category": "devops", "status": "published", "author_id": "789", "is_featured": true, "discount": 20.0, "created_at": "2023-10-29", "out_of_stock": false}
{"index":{"_index": "articles"}}
{"title": "Elasticsearch for Java Developers", "content": "A comprehensive guide to using Elasticsearch with Java.", "category": "technology", "status": "published", "author_id": "123", "is_featured": false, "discount": 0.0, "created_at": "2023-10-25", "out_of_stock": true}
{"index":{"_index": "articles"}}
{"title": "Elasticsearch for Python Developers", "content": "Learn how to use Elasticsearch with Python.", "category": "technology", "status": "published", "author_id": "456", "is_featured": true, "discount": 5.0, "created_at": "2023-10-24", "out_of_stock": false}

3.1 must 子句

  • 作用： must 子句要求文档 必须 匹配其中包含的所有查询条件。可以将其理解为逻辑“与” (AND) 操作。
  • 对得分的影响： 匹配 must 子句中的查询条件会 增加 文档的相关性得分（_score）。匹配的 must 子句越多，得分越高。

示例：

  1. 查找同时包含 “Elasticsearch” 和 “tutorial” 关键词的文章（使用 match 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Elasticsearch" } },
        { "match": { "content": "tutorial" } }
      ]
    }
  }
}

    这个查询要求文档的 title 字段必须包含 “Elasticsearch”，并且 content 字段必须包含 “tutorial”。只有同时满足这两个条件的文章才会被返回。根据我们创建的数据，只有第一条数据 符合这两个条件：

  2. 查找 category 为 “technology” 且 status 为 “published” 的文章（结合 term 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "term": { "category": "technology" } },
        { "term": { "status": "published" } }
      ]
    }
  }
}

    结果：根据我们创建的数据，第一，二，五，六条会被搜索出来

3.2 filter 子句

  • 作用： filter 子句要求文档 必须 匹配其中包含的所有查询条件，但与 must 子句不同的是，filter 子句 不参与 相关性得分计算。它只起到过滤的作用。
  • 对得分的影响： 无影响（过滤器上下文）。所有匹配 filter 子句的文档得分都相同（默认为 1.0，可以通过 constant_score 查询修改）。
  • 优势：
    • 性能更高： 由于不计算得分，filter 子句的执行速度通常比 must 子句更快。
    • 结果可缓存： Elasticsearch 会自动缓存 filter 子句的结果，以提高后续相同过滤条件的查询性能。

示例：

  1. 在搜索结果中过滤出 created_at 在过去三年内并且标题包含「Elasticsearch」的文章（使用 range 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Elasticsearch" } }
      ],
      "filter": [
        { "range": { "created_at": { "gte": "now-3y/y" } } }
      ]
    }
  }
}

    结果：根据我们创建的数据，第一，二，三，四条会被搜索出来

  2. 在搜索结果中过滤出 author_id 为 “123” 的文章（使用 term 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "content": "Elasticsearch" } }
      ],
      "filter": [
        { "term": { "author_id": "123" } }
      ]
    }
  }
}

    结果：根据我们创建的数据，有 3 条会被搜索出来

3.3 should 子句

  • 作用： should 子句表示文档 应该 匹配其中包含的查询条件，但 不是必须 的。可以将其理解为逻辑“或” (OR) 操作。
  • 对得分的影响： 匹配 should 子句中的查询条件会 增加 文档的相关性得分。匹配的 should 子句越多，得分越高。
  • 特殊情况：
    • 如果 bool 查询只包含 should 子句，而没有 must 或 filter 子句，则至少需要匹配一个 should 子句（minimum_should_match 默认为 1）。
    • 如果 bool 查询包含 must 或 filter 子句，则 should 子句变为可选的加分项，即使一个 should 子句都不匹配，文档也会被返回（只要满足 must 或 filter 条件）。

示例：

  1. 搜索文章，优先显示标题中包含 “Elasticsearch” 或 “Logstash” 的文章（使用 match 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "title": "Elasticsearch" } },
        { "match": { "title": "Logstash" } }
      ]
    }
  }
}

    这个查询会返回 title 中包含 “Elasticsearch” 或 “Logstash” 或两者都包含的文章。包含的词项越多，得分越高。由于没有 must 或 filter 子句，至少需要匹配一个 should 子句（minimum_should_match 默认为 1）。根据我们创建的数据，有 5 条会被搜索出来。

  2. 搜索文章，优先显示 is_featured 为 true 或 discount 大于 0 的文章：

    GET articles/_search
{
  "query": {
    "bool": {
       "must": [
        { "match": { "title": "Elasticsearch" } }
      ],
      "should": [
        { "term": { "is_featured": true } },
        { "range": { "discount": { "gt": 0 } } }
      ]
    }
  }
}

    这个查询首先使用 match 查询查找 title 中包含 “Elasticsearch” 的文章, 然后，它使用 should 子句来提升 is_featured 为 true 或 discount 大于 0 的文章的得分。即使文章不满足 should 子句中的任何条件，只要满足 must 子句，仍然会被返回。根据我们创建的数据，第一，四，五，六条会被搜索出来，并且第一，四，六条分数会更高。

3.4 must_not 子句

  • 作用： must_not 子句要求文档 必须不 匹配其中包含的所有查询条件。可以将其理解为逻辑“非” (NOT) 操作。
  • 对得分的影响： 无影响（过滤器上下文）。与 filter 子句类似，must_not 子句不参与相关性得分计算。
  • 注意: 由于 must_not 子句处于过滤器上下文中，因此 Elasticsearch 会自动缓存其结果以提高性能。

示例：

  1. 搜索文章，排除 status 为 “draft” 的文章（使用 term 查询）：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Elasticsearch" } }
      ],
      "must_not": [
        { "term": { "status": "draft" } }
      ]
    }
  }
}

    这个查询首先使用 match 查询查找 title 包含 “Elasticsearch” 的文章（must 子句），然后使用 must_not 子句排除 status 为 “draft” 的文章。只有满足 must 条件且不满足 must_not 条件的文章才会被返回。根据我们创建的数据，第一，四，五，六条会被搜索出来。

  2. 搜索文章，排除 out_of_stock 为 true 且不是is_featured的文章：

    GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        {"match":{"title": "Elasticsearch"}}
      ],
      "must_not": [
        { "term": { "out_of_stock": true } },
        {"term": {"is_featured": false}}
      ]
    }
  }
}

    这个查询首先使用 match 查询查找 title 包含 “Elasticsearch” 的文章, 然后使用 must_not 子句排除 out_of_stock 为 true 且不是is_featured的文章。根据我们创建的数据，第一，四，六条会被搜索出来。

四、minimum_should_match 参数

4.1 什么是 minimum_should_match？

minimum_should_match 参数用于控制 should 子句的行为。它指定了在 bool 查询中，至少需要匹配多少个 should 子句，文档才会被认为是匹配的。

你可以将 minimum_should_match 设置为：

  • 整数： 表示至少需要匹配的 should 子句的数量。
  • 百分比： 表示至少需要匹配的 should 子句占总 should 子句数量的百分比（向下取整）。

4.2 默认值规则

minimum_should_match 的默认值取决于 bool 查询的结构：

  • 只有 should 子句： 如果 bool 查询只包含 should 子句，而没有 must 或 filter 子句，则 minimum_should_match 默认为 1。这意味着至少需要匹配一个 should 子句。
  • 包含 must 或 filter 子句： 如果 bool 查询包含 must 或 filter 子句，则 minimum_should_match 默认为 0。这意味着 should 子句变为可选的加分项，即使一个 should 子句都不匹配，文档也会被返回（只要满足 must 或 filter 条件）。

4.3 使用示例

  1. 设置 minimum_should_match 为具体数值：

    假设我们要搜索文章，要求标题中包含 “Elasticsearch” 或 “Logstash” 或 “Kibana”，并且至少需要匹配其中两个关键词：

    GET articles/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "title": "Elasticsearch" } },
        { "match": { "title": "Logstash" } },
        { "match": { "title": "Kibana" } }
      ],
      "minimum_should_match": 2
    }
  }
}

    这个查询要求至少匹配两个 should 子句。例如，如果一篇文章的标题只包含 “Elasticsearch”，则不会被返回；如果标题包含 “Elasticsearch” 和 “Logstash”，则会被返回。

  2. 设置 minimum_should_match 为百分比：

    假设我们要搜索文章，要求标题或内容中包含 “Elasticsearch”、“Logstash”、“Kibana” 或 “Beats”，并且至少需要匹配其中 50% 的关键词：

    GET articles/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "title": "Elasticsearch" } },
        { "match": { "title": "Logstash" } },
        { "match": { "content": "Kibana" } },
        { "match": { "content": "Beats" } }
      ],
      "minimum_should_match": "50%"
    }
  }
}

    这个查询有 4 个 should 子句，minimum_should_match 设置为 “50%”，这意味着至少需要匹配 4 * 50% = 2 个子句。

4.4 注意事项

当 should 和 must 或者 filter 一起出现的时候，should 会退化为一个加分项，如果一个文档不满足任何 should 中的条件，但是满足 must 中的条件，也是会被搜索出来的。

五、嵌套 Bool 查询

5.1 什么是嵌套 Bool 查询？

嵌套 Bool 查询是指在一个 bool 查询的子句（must、filter、should、must_not）中，再嵌套另一个 bool 查询。通过这种嵌套，你可以构建出非常复杂的查询逻辑，以满足各种细粒度的搜索需求。

5.2 使用场景

嵌套 Bool 查询通常用于以下场景：

  • 构建复杂的逻辑组合： 当你需要组合多个条件，并且这些条件之间存在复杂的 AND、OR、NOT 关系时，可以使用嵌套 Bool 查询。例如，“(A AND B) OR (C AND (D OR E))”。
  • 更精细地控制得分： 通过嵌套 Bool 查询，你可以更精细地控制不同查询子句对最终得分的贡献。例如，你可以将某些条件放在外层 bool 查询的 should 子句中，而将另一些条件放在内层 bool 查询的 must 子句中。

5.3 示例

假设我们需要实现以下搜索需求：

搜索标题中包含 “Elasticsearch” 且 (作者 ID 为 “123” 或为精选文章) 且发布状态不是 “draft” 的文章。

这个需求的逻辑关系比较复杂，可以用如下的逻辑表达式来表示：

(title 包含 "Elasticsearch") AND ((author_id = "123") OR (is_featured = true)) AND (status != "draft")

我们可以使用嵌套 bool 查询来实现这个需求：

GET articles/_search
{
  "query": {
    "bool": {
      "must": [
        { "match": { "title": "Elasticsearch" } },
        {
          "bool": {
            "should": [
              { "term": { "author_id": "123" } },
              { "term": { "is_featured": true } }
            ],
            "minimum_should_match": 1
          }
        },
        {
          "bool": {
            "must_not": [
              { "term": { "status": "draft" } }
            ]
          }
        }
      ]
    }
  }
}

解释：

  • 外层 bool 查询：
    • 使用 must 子句组合三个条件：
      1. match 查询：标题包含 “Elasticsearch”。
      2. 嵌套的 bool 查询：作者 ID 为 “123” 或为精选文章。
      3. 嵌套的 bool 查询 (使用must_not): 排除 status 为 draft 的文章。
  • 内层 bool 查询（作者/精选）：
    • 使用 should 子句组合两个条件：
      1. term 查询：作者 ID 为 “123”。
      2. term 查询：is_featured 为 true。
    • minimum_should_match: 1，表示至少需要匹配一个 should 子句。
  • 内层 bool 查询 (排除状态)：
    • 使用 must_not 子句，其内部是一个 term 查询，用于排除 status 为 draft。

六、Bool 查询与相关性得分

6.1 Bool 查询如何影响得分？

bool 查询的子句对文档相关性得分（_score）的影响，我们已经在前面的章节中详细讨论过：

  • must 子句： 匹配的 must 子句越多，文档得分越高。
  • filter 子句： 不影响得分。
  • should 子句： 匹配的 should 子句越多，文档得分越高。
  • must_not 子句： 不影响得分。

总结： must 和 should 子句会影响得分，而 filter 和 must_not 子句不影响得分。

6.2 调整子句的权重

在某些情况下，你可能希望调整不同查询子句对得分的贡献。例如，你可能希望标题中包含关键词的文档比内容中包含关键词的文档得分更高。

你可以使用 boost 参数来调整查询子句的权重。boost 参数是一个正数，用于增加或减少查询子句的相对重要性。boost 的默认值为 1.0。

示例：

假设我们搜索文章，希望标题中包含 “Elasticsearch” 的文档比内容中包含 “Elasticsearch” 的文档得分更高：

GET articles/_search
{
  "query": {
    "bool": {
      "should": [
        { "match": { "title": { "query": "Elasticsearch", "boost": 2.0 } } },
        { "match": { "content": "Elasticsearch" } }
      ]
    }
  }
}

在这个查询中，我们为标题的 match 查询设置了 boost 值为 2.0。这意味着标题中包含 “Elasticsearch” 的文档的得分将比内容中包含 “Elasticsearch” 的文档的得分更高（大约是两倍）。

注意： boost 参数只是一个提示，Elasticsearch 不保证得分的精确比例。实际得分还受到其他因素的影响，例如词频、逆文档频率等。

八、总结

bool 查询是 Elasticsearch 中一种非常强大且灵活的查询工具，它可以帮助你构建复杂的查询逻辑，以满足各种搜索需求。通过组合 must、filter、should 和 must_not 四种子句，以及使用 minimum_should_match 参数和嵌套 bool 查询，你可以实现对搜索结果的精细控制。

希望本文能够帮助你深入理解 Elasticsearch 7.10 版本中的 bool 查询，并在实际应用中灵活运用。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2304318.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

查看cmd下python的安装路径 + Windows 命令行添加环境变量和不重启刷新环境变量

查看cmd下python的安装路径 + Windows 命令行添加环境变量和不重启刷新环境变量

1、查看cmd下python的安装路径 cmd ----》输入“python” 命令 ---》输入 import sys; print(sys.executable) 即可看到当前系统python的安装路径： 注：系统所使用的python实际上就是在系统环境变量下配置的python目录。 2、刷新path命令：在c…
阅读更多...
C/C++跳动的爱心

C/C++跳动的爱心

系列文章 序号直达链接1C/C李峋同款跳动的爱心2C/C跳动的爱心3C/C经典爱心4C/C满屏飘字5C/C大雪纷飞6C/C炫酷烟花7C/C黑客帝国同款字母雨8C/C樱花树9C/C奥特曼10C/C精美圣诞树11C/C俄罗斯方块小游戏12C/C贪吃蛇小游戏13C/C孤单又灿烂的神14C/C闪烁的爱心15C/C哆啦A梦16C/C简单…
阅读更多...
Cannot deserialize instance of java.lang.String out of START_ARRAY token

Cannot deserialize instance of java.lang.String out of START_ARRAY token

这个错误 Cannot deserialize instance of java.lang.String out of START_ARRAY token 表示 Jackson 正在尝试将一个 JSON 数组反序列化成一个 String 类型的字段，但是 JSON 中传递的是一个数组而不是单一的字符串。 具体来说，这段堆栈信息&#xff1a…
阅读更多...
一、初始爬虫

一、初始爬虫

1.爬虫的相关概念 1.1 什么是爬虫 网络爬虫（又被称为网页蜘蛛，网络机器人）就是模拟浏览器发送网络请求，接收请求响应，一种按照一定的规则，自动地爬取互联网信息的程序。 原则上，只要是浏览器…
阅读更多...
在低功耗MCU上实现人工智能和机器学习

在低功耗MCU上实现人工智能和机器学习

作者：Silicon Labs 人工智能（AI）和机器学习（ML）技术不仅正在快速发展，还逐渐被创新性地应用于低功耗的微控制器（MCU）中，从而实现边缘AI/ML解决方案。这些MCU是许多嵌入式…
阅读更多...
QQ登录测试用例报告

QQ登录测试用例报告

QQ登录测试用例思维导图 一、安全性测试用例 1. 加密传输与存储验证 测试场景：输入账号密码并提交登录请求。预期结果：账号密码通过加密传输（如HTTPS）与存储（如哈希加盐），无明文暴露。 2. 二…
阅读更多...
细说STM32F407单片机2个ADC使用DMA同步采集各自的1个输入通道的方法

细说STM32F407单片机2个ADC使用DMA同步采集各自的1个输入通道的方法

目录 一、示例说明 二、工程配置 1、RCC、DEBUG、CodeGenerator 2、USART6 3、TIM3 （1）Mode （2）参数设置 （3） TRGO （4）ADC1_IN0 1）ADCs_Common_Settings 2&a…
阅读更多...
[python脚本]论文1.（一）CPU/内存数据分析和分组

[python脚本]论文1.（一）CPU/内存数据分析和分组

CPU 收集到的CPU数据，格式如下： 由于这里6个数据为一组来收集latency的数据以及各个分位值的数据，而本质上每一行都是一次完整的测试，因此这里将这个csv文件分为两个文件，第一个是和latency相关的，将6条数…
阅读更多...
一周学会Flask3 Python Web开发-Jinja2模板基本使用

一周学会Flask3 Python Web开发-Jinja2模板基本使用

锋哥原创的Flask3 Python Web开发 Flask3视频教程： 2025版 Flask3 Python web开发 视频教程(无废话版) 玩命更新中~_哔哩哔哩_bilibili 我们平台开发web系统，必须用到网页，单纯的静态网页无法满足我们的需求。我们可以使用模版引擎技术&am…
阅读更多...
《操作系统 - 清华大学》8 -3：进程管理：进程特点

《操作系统 - 清华大学》8 -3：进程管理：进程特点

深入剖析进程的特点、实现及进程控制块 一、进程的特点 （一）动态性 进程具有明显的动态性。它可以被动态创建，在执行过程中会发生状态切换，从一个状态转变为另一个状态。当所有任务执行完毕后，进程还会结束运行。整…
阅读更多...
Java 大视界 -- 总结与展望：Java 大数据领域的新征程与无限可能（96）

Java 大视界 -- 总结与展望：Java 大数据领域的新征程与无限可能（96）

💖亲爱的朋友们，热烈欢迎来到 青云交的博客！能与诸位在此相逢，我倍感荣幸。在这飞速更迭的时代，我们都渴望一方心灵净土，而 我的博客 正是这样温暖的所在。这里为你呈上趣味与实用兼具的知识，也…
阅读更多...
【微服务】深入解析spring aop原理

【微服务】深入解析spring aop原理

目录 一、前言 二、AOP 概述 2.1 什么是AOP 2.2 AOP中的一些概念 2.2.1 aop通知类型 2.3 AOP实现原理 2.3.1 aop中的代理实现 2.4 静态代理与动态代理 2.4.1 静态代理实现 三、 jdk动态代理与cglib代理 3.1 jdk动态代理 3.1.1 jdk动态代理模拟实现 3.2 CGLIB 代理…
阅读更多...
pikachu靶场搭建教程

pikachu靶场搭建教程

需要的东西 phpStudy： 链接： https://pan.baidu.com/s/1fJ-5TNtdDZGUf5FhTm245g 提取码：0278 pikachu-master： Github链接：https://github.com/zhuifengshaonianhanlu/pikachu 链接： https://pan.baidu.c…
阅读更多...
游戏引擎学习第119天

游戏引擎学习第119天

仓库:https://gitee.com/mrxiao_com/2d_game_3 上一集回顾和今天的议程 如果你们还记得昨天的进展，我们刚刚完成了优化工作，目标是让某个程序能够尽可能快速地运行。我觉得现在可以说它已经快速运行了。虽然可能还没有达到最快的速度，但我们…
阅读更多...
从零开始制作一个漂亮的悬浮按钮

从零开始制作一个漂亮的悬浮按钮

0.1血版 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Document</title> </head> &l…
阅读更多...
Win11更新系统c盘爆满处理

Win11更新系统c盘爆满处理

1.打开磁盘管理 2.右击c盘选择属性&#xff0c;进行磁盘管理&#xff0c;选择详细信息。 3.选择以前安装的文件删除即可释放c盘空间。
阅读更多...
从零实现机器人自主避障

从零实现机器人自主避障

1. 编译工具安装 sudo apt update sudo apt install python3-catkin-pkg python3-rosdep python3-rosinstall-generator python3-wstool python3-rosinstall build-essential sudo rosdep init rosdep update2. 构建节点 mkdir -p ~/ros2_ws/src cd ~/ros2_ws ros2 pkg creat…
阅读更多...
【Nacos】从零开始启动Nacos服务（windows/linux)

【Nacos】从零开始启动Nacos服务（windows/linux)

文章目录 前言前置条件官方网址一、Nacos下载1.1 选择Nacos版本1.2 下载 二、解压2.1 解压到某个文件夹 三、 启动3.1 方式一&#xff1a;直接使用命令启动3.1.1 进入bin文件夹3.1.2 进入命令行工具3.1.3 执行命令 3.2 方式二&#xff1a;修改配置文件后启动3.2.1 修改启动脚本…
阅读更多...
即插即用Transformer、扩散模型、机器人规划、长文本检索增强生成 | Big Model Weekly 第57期...

即插即用Transformer、扩散模型、机器人规划、长文本检索增强生成 | Big Model Weekly 第57期...

点击蓝字 关注我们 AI TIME欢迎每一位AI爱好者的加入&#xff01; 01 ProTransformer: Robustify Transformers via Plug-and-Play Paradigm 近年来&#xff0c;基于Transformer的架构在机器学习的各个领域占据了主导地位。本文介绍了一种新颖的鲁棒性注意力机制&#xff0c;旨…
阅读更多...
FPGA DSP：Vivado 中带有 DDS 的 FIR 滤波器

FPGA DSP：Vivado 中带有 DDS 的 FIR 滤波器

本文使用 DDS 生成三个信号&#xff0c;并在 Vivado 中实现低通滤波器。低通滤波器将滤除相关信号。 介绍 用DDS生成三个信号&#xff0c;并在Vivado中实现低通滤波器。低通滤波器将滤除较快的信号。 本文分为几个主要部分&#xff1a; 信号生成&#xff1a;展示如何使用DDS&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023