跳至内容
免费开始
返回博客

适用于网络爬虫的 CSS 选择器速查表:语法与代码

Ștefan Răcilă最后更新于 8 min read
适用于网络爬虫的 CSS 选择器速查表:语法与代码

CSS 选择器是用于从 HTML 文档中筛选元素的模式,爬虫利用它们来定位需要提取的具体文本或属性。其中五种选择器承担了大部分工作: .class, [attribute]、后代和子元素组合符(空格和 >), :nth-child(),以及 :has()。这份 CSS 选择器速查表涵盖了所有这些选择器以及其余的标准语法,每项都配有相应的爬取示例。 此外,您还将看到一张矩阵,展示哪些选择器在浏览器、BeautifulSoup、Scrapy、Cheerio、Playwright 和 selectolax 中有效;同一提取任务在四种技术栈中的实现示例;常见页面模式的处理方案;以及针对返回空结果的选择器的修复方案表。

关键要点

  • 大多数爬取任务仅需类名、属性名、空格以及 > 组合符, :nth-child()以及 :has().
  • :has() 选择父元素。现代浏览器和主流抓取解析器均支持这些功能。
  • 标准 CSS 无法选择文本或属性值。 ::text, ::attr(),以及 :-soup-contains() 属于库扩展功能,而非 CSS 本身。
  • 锚点位于 data-* 基于属性及语义类,而非构建哈希类或冗长的复制链。
  • 如果某个选择器在开发者工具中有效,但在您的爬虫中无效,那么该内容很可能是由 JavaScript 渲染的。

什么是网页抓取中的 CSS 选择器?

CSS 选择器通过标签、类、ID、属性、位置或其他元素之间的关系来匹配元素。浏览器使用它们来应用样式。爬虫使用相同的语法来查找包含数据的元素,然后将每个元素的文本或属性读取到名称、价格和 URL 等字段中。

HTML 页面解析后会形成一棵树:每个标签都是一个节点,拥有父节点、同级节点和子节点。选择器描述了该树中的路径或条件,解析器会返回所有符合条件的节点。

几乎所有的网页抓取工具都遵循相同的四个步骤:

  1. 使用 HTTP 客户端或浏览器获取页面。
  2. 将 HTML 解析为树结构。
  3. 使用 CSS 选择器筛选出您关注的节点。
  4. 提取文本或属性值,并将其保存为记录。

关键的分岔点在于第一步。例如,像 requests、Node.js的 fetch或 Scrapy 的下载器会接收服务器发送的原始 HTML,而 BeautifulSoup、Parsel 和 Cheerio 等解析器则基于此进行处理。浏览器会先执行页面的 JavaScript,因此选择器看到的是渲染后的 DOM,其中可能包含原始响应中从未出现的内容。 当页面在 Playwright 等无头浏览器或渲染 API 中渲染时,情况正是如此。分叉的两侧,你的选择器语法保持不变。然而,它所操作的树结构可能截然不同,而这种差异正是导致大多数“我的选择器返回空结果”错误的原因。

本页面的每个示例均基于同一个小型产品列表运行,因此您可以逐行比较代码:

<main id="catalog">
  <div class="product card" data-sku="A1" data-testid="product">
    <h2 class="title">Blue Mug</h2>
    <span class="price">$12.00</span>
    <span class="badge sale">Sale</span>
    <a class="link" href="/p/blue-mug">View</a>
    <img src="/img/a1.jpg" alt="Blue Mug">
  </div>
  <div class="product card" data-sku="b2" data-testid="product">
    <h2 class="title">Red Mug</h2>
    <span class="price">$14.00</span>
    <a class="link" href="/p/red-mug">View</a>
    <a class="spec" href="/files/red-mug.pdf">Spec sheet</a>
    <img src="/img/blank.gif" data-src="/img/b2.jpg" alt="Red Mug">
  </div>
  <div class="product card out-of-stock" data-sku="C3" data-testid="product">
    <h2 class="title">Green Mug</h2>
    <span class="price">$9.00</span>
    <p class="note">Out of stock</p>
    <a class="link" href="/p/green-mug">View</a>
  </div>
  <table class="specs">
    <tr><th>Name</th><th>Value</th></tr>
    <tr><td>Weight</td><td>300 g</td></tr>
    <tr><td>Color</td><td>Blue</td></tr>
  </table>
  <dl class="details">
    <dt>Material</dt><dd>Stoneware</dd>
    <dt>Capacity</dt><dd>350 ml</dd>
  </dl>
  <ul class="pager">
    <li><a href="?page=1">1</a></li>
    <li class="active"><a href="?page=2">2</a></li>
    <li><a href="?page=3">3</a></li>
  </ul>
  <a rel="next" href="?page=3">Next</a>
</main>

CSS 选择器速查表

下表按类型分组列出了所有对数据抓取至关重要的标准选择器,包括每个选择器的匹配规则以及针对上述产品列表的示例。仅在特定库中提供的扩展选择器(如 ::text 则单独列于另一张表格中,因为一旦更换库,这些扩展就会失效。如需查看完整标准,请参阅 MDN 的 CSS 选择器参考文档。

基本选择器

选择器

匹配对象

抓取示例

*

所有元素

.product > * 在映射不熟悉的布局时,列出卡片的所有直接子元素

tag

具有该标签名的元素

h2 返回三个产品标题

.class

带有该类的元素

.price 返回全部三个价格

.a.b

同时具有这两个类的元素

.product.card 返回这三张卡片

#id

具有该 ID 的元素

#catalog 将范围限定为该商品列表

tag.class

具有该类的该标签

div.product 跳过所有非div 元素

一个空格会彻底改变含义。 .product.card (无空格)表示一个同时具有这两个类的元素。 .product .card (带空格)表示 .card 某个 .product,且在本页面上无法匹配任何内容。这个单个空格是新爬虫中最常见的第一个错误。

对于单一值(例如一个页面标题或一个容器),请使用 ID。而重复出现的元素(如产品卡片或结果行)几乎从不带有 ID,因此应通过类名或属性来选择它们。

属性选择器

选择器

匹配

抓取示例

[attr]

该属性存在

[data-sku] 返回所有具有 SKU 的卡片

[attr="v"]

值完全为 v

[data-sku="A1"] 返回一张商品卡片

[attr~="v"]

v 是空格分隔列表中的一个单词

[class~="sale"] 匹配 class="badge sale" 但不匹配 presale

[attr|="v"]

该值为 v 或以 v-

[lang|="en"] 匹配 en 且 en-US

[attr^="v"]

该值以...开头 v

a[href^="/p/"] 仅返回产品链接

[attr$="v"]

该值以...结尾 v

a[href$=".pdf"] 返回产品规格表

[attr*="v"]

该值包含 v 任意位置

a[href*="mug"] 返回所有马克杯链接

[attr="v" i]

精确匹配,忽略ASCII大小写

[data-sku="a1" i] 匹配 data-sku="A1"

请对包含空格、斜杠、点或其他特殊字符的任何值加引号。 a[href$=".pdf"] 是安全的,但 a[href$=.pdf] 在大多数解析器中会引发语法错误。

属性选择器通常是页面上最稳定的挂钩。 data-* 属性、 itemprop, aria-label以及 rel 之所以存在,是因为网站自身的代码或无障碍工具依赖于它们。正因如此,即使在重新设计时重命名了视觉类,它们通常也能得以保留。

组合符

选择器

匹配

抓取示例

A B

B 位于 A

#catalog .price 返回列表中所有价格

A > B

B 且是 A

.product > .title 跳过更深层级的标题

A + B

B 紧接在 A之后,且与该标题同级

.title + .price 返回紧跟在每个标题后面的价格

A ~ B

任何 B 位于 A,同一父级

.title ~ a 返回每张卡片中标题后面的所有链接

A, B

匹配任一选择器的元素

.title, .price 将标题和价格一起返回

分组后的结果按文档顺序返回,而非你列出选择器的顺序。 .title, .price 无论在浏览器、BeautifulSoup 还是 Cheerio 中,都会按“名称、价格、名称、价格”的顺序返回结果。

CSS 没有父元素组合符,也没有前一个同级元素组合符。你不需要这两者,因为 :has() 可以同时满足这两种需求,如下文的逻辑部分所示。

位置伪类

选择器

匹配

抓取示例

:first-child

其父元素的第一个子元素

div.product:first-child 返回第一张卡片

:last-child

其父元素的最后一个子元素

.pager li:last-child a 返回最后一个页面链接

:nth-child(n)

第 n 个子元素(从 1 开始计数)

div.product:nth-child(2) .title 返回“红杯”

:nth-child(odd) / (even)

每隔一个子节点

tr:nth-child(even) 适用于条纹表格

:nth-child(n+2)

从第二个开始的每个子元素

tr:nth-child(n+2) 跳过一行标题行

:nth-last-child(n)

从末尾开始数第n个孩子

li:nth-last-child(1) 返回最后一个分页项

:only-child

没有同级元素的元素

td:only-child 会查找仅含一个单元格的行

:first-of-type

具有该标签的第一个同级元素

span:first-of-type 返回每张卡片中的价格

:last-of-type

具有该标签的最后一个同级元素

div.product:last-of-type 返回最后一张卡片

:nth-of-type(n)

带有其标签的第 n 个同级元素

span:nth-of-type(2) 返回促销徽章

:only-of-type

带有其标签的唯一同级卡片

h2:only-of-type 每张卡片返回一个标题

该 An+B 内部的公式 :nth-child() 从1开始计数, n 取值为 0、1、2 等等。 n+2 因此表示第 2、3、4 位及之后的项,这就是跳过表格标题行的方式。 -n+3 表示第 3、2 和 1 位,因此会选取前三个项目。 2n 等同于 even,而 2n+1 等同于 odd。任何超出实际子节点数量范围的匹配都会被忽略。

:nth-child() 和 :nth-of-type() 看起来相似,但计数方式不同。在第一张卡片中,子节点数量为 h2, span.price, span.badge, a,而 img. span:nth-child(2) 返回价格,因为价格是整体上的第二个子节点。 span:nth-of-type(2) 返回“促销”标签,因为该标签是第二个 span.

在 Scrapy 和 Parsel 中, *-of-type 伪类需要一个元素名称。 div.product:nth-of-type(2) 可以正常工作,但 .product:nth-of-type(2) 会引发一个 ExpressionError。浏览器、BeautifulSoup 和 Cheerio 均支持这两种形式。

逻辑伪类::not()、:is()、:where() 和 :has()

选择器

匹配

抓取示例

:not(x)

不匹配的元素 x

div.product:not(.out-of-stock) 返回库存中的两张卡片

:is(x, y)

匹配列表中任意选择器的元素

:is(h2, h3).title 处理混合了不同标题级别的模板

:where(x, y)

与 :is(),且特异性为零

可与 :is() 用于数据抓取

:has(x)

包含与 x

div.product:has(.badge) 将返回正在促销的卡片

:has(> x)

具有直接子元素匹配 x

div.product:has(> .note) 返回缺货卡片

:has(+ x)

紧跟在 x

dt:has(+ dd) 将返回每个具有值的标签

:has() 是 CSS 多年来一直缺失的父级选择器。它根据元素内部的内容或紧随其后的内容来匹配元素,这涵盖了爬虫通常需要的两个方向。 .product:has(.badge) 返回包含促销标识的卡片,而非标识本身。 tr:has(td.out-of-stock) 返回包含缺货单元格的整行表格。 dt:has(+ dd) 仅当标签后紧跟一个值时才返回该标签,这就是访问前一个同级元素的方法。将其与 :not() 可反转条件: .product:not(:has(.badge)) 返回没有标签的卡片。该特性由《选择器第4级》规范定义,MDN上的:has()将其列为“基线级,广泛可用”,自2023年12月起已在各浏览器中支持。BeautifulSoup、Scrapy、Cheerio、Playwright和selectolax也支持该特性。有一项限制:不能将 :has() 在另一个 :has().

:is() ,且与 :where() 仅在特异性上有所不同,这会影响样式表中哪种样式优先。特异性对爬虫的选择结果没有影响,因此请选择读起来更顺畅的写法。

仅限库的扩展

标准 CSS 仅选择元素,绝不会选择其文本或属性值。每个爬虫库都以自己的方式填补这一空白,而以下扩展正是导致你的代码失去可移植性的原因。

扩展

库

功能说明

::text

Scrapy、Parsel

选择匹配元素的文本节点

::attr(name)

Scrapy、Parsel

获取一个属性的值

:-soup-contains("x")

BeautifulSoup(通过 Soup Sieve)

匹配其文本(包括子元素)中包含特定内容的元素 x

:-soup-contains-own("x")

BeautifulSoup(通过 Soup Sieve)

匹配其自身文本(不包括子元素)中包含特定内容的元素 x

:contains("x")

Cheerio、Parsel(通过 cssselect)

匹配其文本中包含 x

:has-text("x")

仅限 Playwright 定位器

匹配包含 x 内部任意位置,不区分大小写

:text("x")

仅限 Playwright 定位器

匹配包含该内容的最小元素 x

:visible

仅限 Playwright 定位器

仅匹配页面上可见的元素

这些都不是标准 CSS。浏览器的 document.querySelectorAll() 会抛出 SyntaxError :contains(),而若向 BeautifulSoup 传入 ::text,BeautifulSoup 会抛出错误。在 BeautifulSoup 中, :contains() 仍然作为别名有效,但已被弃用,建议改用 :-soup-contains()。Soup Sieve(BeautifulSoup 的选择器引擎)在其文档中详细列出了所有扩展。

CSS 选择器无法实现的功能

CSS 是一种匹配语言,因此有几项任务超出了它的范围:

  • 单独选择文本节点或属性值。你需要先选择元素,然后在代码中读取其文本或属性。
  • 在标准 CSS 中根据文本内容进行匹配。只有上述库扩展才能实现这一点。
  • 沿父代向上遍历固定层级,例如“此 span 的祖父元素”。 :has() 这种选择是基于包含关系,而非距离。
  • 比较值或进行数学运算,例如“价格大于 10”。
  • 跨入 iframe(即独立文档)。

当遇到上述任一限制时,请参考网页抓取的 XPath 速查表,或在选择后通过代码实现该步骤。

哪些 CSS 选择器在哪些爬虫库中有效?

标准选择器,包括属性运算符, :nth-child(), :not(), :is()以及 :has(),在现代浏览器、BeautifulSoup、Scrapy、Cheerio、Playwright 和 selectolax 中行为一致。差异主要体现在扩展功能和边界情况上:Scrapy 和 Parsel 需要标签名来匹配 *-of-type,BeautifulSoup 拒绝 ::text,且各库匹配文本的方式各不相同。

特性

浏览器 (querySelectorAll)

BeautifulSoup

Scrapy / Parsel

Cheerio

Playwright

selectolax

属性运算符与 i 标志

是

是

是

是

是

是

组合子(空格、 >, +, ~, ,)

是

是

是

是

是

是

An+B (:nth-child(n+2))

是

是

是

是

是

是

*-of-type 无标签 (.product:nth-of-type(2))

是

是

错误

是

是

是

*-of-type 带有标签(div.product:nth-of-type(2))

是

是

是

是

是

是

:not()

是

是

是

是

是

是

:is() 以及 :where()

是

是

是

是

是

是

:has() 以及 :has(> x)

是

是

是

是

是

是

:scope

是

是

是

是

是

错误

::text 和 ::attr()

错误

错误

扩展名

错误

错误

错误

文本匹配

无(:contains() 抛出)

扩展 (:-soup-contains())

扩展 (:contains())

扩展 (:contains())

扩展 (:has-text(), :text())

扩展 (:lexbor-contains())

打开 Shadow DOM

否

否

否

否

是(CSS 会穿透开放的 Shadow 根节点)

否

截至2026年11月的最新情况。

两行代码是导致大多数迁移错误的主因。当你将一个包含 .something:nth-of-type(),请添加标签名。将Scrapy选择器移入BeautifulSoup时,请去除 ::text 并 ::attr() ,转而在 Python 中读取文本或属性。

关于阴影 DOM 这一行需要特别说明。原始 HTML 解析器永远无法看到由 JavaScript 附加的阴影根节点,因为这些节点在服务器的响应中并不存在。只有浏览器才能访问它们,而且只有 Playwright 的 CSS 引擎默认会穿透阴影根节点。

PHP 爬虫通过 Symfony 的 CssSelector 组件遵循相同的规则。该组件会在执行 CSS 选择器之前将其转换为 XPath,因此该转换所涉及的任何限制同样适用。

如何查找和测试 CSS 选择器?

检查该元素,记录其标签、类和数据属性,找到向上一到两层的稳定容器,并编写一个在该容器内唯一的简短选择器。然后在“元素”面板中使用 Ctrl+F 进行测试,或 document.querySelectorAll() 在控制台中使用 Ctrl+F 进行测试,并确认匹配数量与预期一致。

  1. 检查。右键单击目标值并选择“检查”。“元素”面板会高亮显示该节点。
  2. 阅读锚点。查找 data-* 属性、 id,以及语义类名,例如 price 或 title, itemprop等语义类名,以及 aria-* 属性。这些是变化可能性最小的锚点。
  3. 找出重复出现的容器。对于列表,向上遍历直到找到那个每项重复一次的元素,例如 div.product.
  4. 编写在容器内部唯一且最短的选择器。 div.product .price 比遍历每个包装器更高效。
  5. 进行测试。在“元素”面板中按 Ctrl+F(macOS 上为 Cmd+F),然后粘贴该选择器。开发者工具会显示匹配次数。你也可以在控制台中运行它:

``js $$("div.product .price").length // 3 ``

  1. 与“查看源代码”进行对比。打开“查看源代码”(Ctrl+U)并搜索该值。如果找不到,则说明该内容由 JavaScript 渲染,HTTP 客户端无法看到它。

所有主流浏览器均可从“元素”面板复制生成的选择器。右键单击节点并打开“复制”子菜单:

浏览器

菜单项

Chrome 和 Edge

复制 > 复制选择器

Firefox

复制 > CSS 选择器

Safari

复制 > 选择器路径

Chrome 开发者工具的 DOM 指南对“元素”面板进行了更深入的介绍。

如何简化复制的选择器

复制的选择器仅描述当前页面,不包含其他内容。例如,第二张卡片价格的典型复制内容如下:

/* Copied from DevTools */
#catalog > div:nth-child(2) > span

/* Rewrite 1: one card, by a stable attribute */
[data-sku="b2"] .price

/* Rewrite 2: every card */
div.product .price

复制的版本取决于卡片的位置,且价格是该卡片中唯一的 span 。若在顶部添加一张赞助卡片,它将返回错误产品的价格;若在此卡片上添加促销标识,它将返回两个值而非一个。重写 1 将位置替换为产品自身的 SKU,并将裸露的 span 替换为语义类。重写方案2则完全去除了“单张卡片”的条件,因为爬虫通常需要获取所有价格,而非仅第二张卡片的价格。每去除一层条件,就少了一项必须保持不变的要素。

健壮与脆弱的选择器

脆弱

健壮

原因

.css-1x9k2ab

[data-testid="product"]

构建工具会在每次部署时重新生成哈希类名,而测试 ID 则会保留,因为网站自身的测试依赖于它们

main > div:nth-child(3) > div:nth-child(2) > span

.product .price

一旦添加或移除任何包装类,完整的定位路径就会失效

.text-red.font-bold

.price

呈现类会随着重设计而改变,而语义类则描述内容

div.product:nth-child(2)

[data-sku="b2"]

当项目被排序或插入时,其位置会发生变化,而项目的 ID 则保持不变

div > div > span

.price

通用标签链匹配范围过广,且依赖于精确的嵌套结构

健壮的选择器应锚定在网站开发者所依赖的元素上:测试ID、数据属性、语义类以及结构化数据标记,例如 itemprop.

如何在 Python 和 JavaScript 中使用 CSS 选择器提取数据

每个库都接受相同的选择器字符串,但返回结果的方式各不相同: select() 以及 select_one() 在 BeautifulSoup 中, response.css() 而 ::text 以及 ::attr() 在 Scrapy 中, $() 在 Cheerio 中,以及 page.locator() 在 Playwright 中。这种模式在所有地方都是一致的:先选取每个重复项,然后读取其中的字段。

下面的每个示例都会从列表中的三张卡片中提取名称、价格和绝对 URL。

BeautifulSoup

from urllib.parse import urljoin
import requests
from bs4 import BeautifulSoup

URL = "https://shop.example.com/mugs?page=2"
soup = BeautifulSoup(requests.get(URL, timeout=10).text, "lxml")

for card in soup.select("div.product"):
    title = card.select_one(".title")
    price = card.select_one(".price")
    link = card.select_one("a.link")
    print({
        "name": title.get_text(strip=True) if title else None,
        "price": price.get_text(strip=True) if price else None,
        "url": urljoin(URL, link.get("href")) if link else None,
    })
# {'name': 'Blue Mug', 'price': '$12.00', 'url': 'https://shop.example.com/p/blue-mug'}
# {'name': 'Red Mug', 'price': '$14.00', 'url': 'https://shop.example.com/p/red-mug'}
# {'name': 'Green Mug', 'price': '$9.00', 'url': 'https://shop.example.com/p/green-mug'}
  • select() 返回一个列表,而 select_one() 返回第一个匹配项,或 None。在调用方法之前,请为每个 select_one() 。
  • tag["href"] 会引发一个 KeyError ,而 tag.get("href") 则返回 None.
  • ::text 会引发错误。请改用 get_text(strip=True) ,并 :-soup-contains("Out of stock") 当需要按文本进行匹配时。
  • 解析器对损坏的 HTML 至关重要。 lxml 和 html.parser 可能会从相同的格式错误标记中构建出不同的树结构,因此请选择其中一种并坚持使用。

若要深入学习,可以从零开始构建一个 BeautifulSoup 爬虫,或者阅读 BeautifulSoup 文档以了解完整的 select() API。

Scrapy 和 Parsel

import scrapy

class MugSpider(scrapy.Spider):
    name = "mugs"
    start_urls = ["https://shop.example.com/mugs?page=2"]

    def parse(self, response):
        for card in response.css("div.product"):
            yield {
                "name": card.css(".title::text").get(default="").strip(),
                "price": card.css(".price::text").get(default="").strip(),
                "url": response.urljoin(card.css("a.link::attr(href)").get()),
            }
        # {'name': 'Blue Mug', 'price': '$12.00', 'url': 'https://shop.example.com/p/blue-mug'}
        # {'name': 'Red Mug', 'price': '$14.00', 'url': 'https://shop.example.com/p/red-mug'}
        # {'name': 'Green Mug', 'price': '$9.00', 'url': 'https://shop.example.com/p/green-mug'}
        next_page = response.css('a[rel="next"]::attr(href)').get()
        if next_page:
            yield response.follow(next_page, callback=self.parse)

这份 Scrapy CSS 选择器速查表涵盖了你最常使用的调用:

语法

返回值

示例代码

::text

元素自身的文本节点

.title::text 返回“Blue Mug”

::text (开头空格)

该元素及其所有子元素的文本节点

.product ::text 返回卡片中的所有文本节点

::attr(name)

某个属性的值

a.link::attr(href) 返回“/p/blue-mug”

.get()

第一个结果,或 None

card.css(".price::text").get()

.getall()

将所有结果作为列表返回

response.css(".title::text").getall()

.get(default="")

第一个结果,或您的默认值

避免 None 在 .strip()

.attrib["href"]

第一个匹配元素的属性

card.css("a.link").attrib["href"]

  • *-of-type 需要标签名。请写成 div.product:nth-of-type(2),而不是 .product:nth-of-type(2).
  • a::text 和 a ::text 是不同的。前者仅返回链接本身的文本节点,而后者还会返回嵌套标签内的文本,例如 <a><span>View</span></a>.
  • 返回的文本为原始格式,包含换行和缩进,因此需进行清理。

Scrapy 的选择器源自 Parsel,因此相同的 .css() 调用在 parsel.Selector(text=html) 蜘蛛外部同样有效。有关扩展规则,请参阅 Scrapy 的选择器文档;如需了解爬取、管道和配置的详细信息,请参考完整的 Scrapy 爬取指南。

Cheerio

import * as cheerio from "cheerio";

const URL = "https://shop.example.com/mugs?page=2";
const $ = cheerio.load(await (await fetch(URL)).text());

const products = $("div.product").map((i, el) => {
  const card = $(el);
  return {
    name: card.find(".title").text().trim(),
    price: card.find(".price").text().trim(),
    url: new URL(card.find("a.link").attr("href"), URL).href,
  };
}).get();
console.log(products);
// [ { name: 'Blue Mug', price: '$12.00', url: 'https://shop.example.com/p/blue-mug' },
//   { name: 'Red Mug', price: '$14.00', url: 'https://shop.example.com/p/red-mug' },
//   { name: 'Green Mug', price: '$9.00', url: 'https://shop.example.com/p/green-mug' } ]
  • Cheerio 仅解析原始 HTML。它不执行 JavaScript,因此加载后脚本添加的任何内容都不会被包含。
  • .text() 对包含多个元素的选择器进行操作时,会将所有元素的文本合并,因此范围限定为一张卡片, .find() 。
  • .attr("href") 返回 undefined 当该属性缺失时。
  • :contains() 该操作在 Cheerio 中有效,但在浏览器中会抛出异常,因此您在此处原型化的选择器可能无法直接粘贴回控制台。

有关完整项目,请参阅 Node.js 中的 Cheerio 网络爬虫。

Playwright

import { chromium } from "playwright";

const browser = await chromium.launch();
const page = await browser.newPage();
await page.goto("https://shop.example.com/mugs?page=2");
await page.locator("div.product").first().waitFor();

const names = await page.locator("div.product .title").allInnerTexts();
// [ 'Blue Mug', 'Red Mug', 'Green Mug' ]
const products = await page.$$eval("div.product", cards =>
  cards.map(card => ({
    name: card.querySelector(".title")?.innerText.trim() ?? null,
    price: card.querySelector(".price")?.innerText.trim() ?? null,
    url: card.querySelector("a.link")?.href ?? null,
  }))
);
// [ { name: 'Blue Mug', price: '$12.00', url: 'https://shop.example.com/p/blue-mug' }, ... ]
await browser.close();
  • 诸如 allInnerTexts() 和 count() 等定位方法不会等待元素出现,而 $$eval() 仅针对当前 DOM 执行一次。请先等待容器出现,如上所述。
  • 在 $$eval()中, href 该属性返回一个绝对 URL,而 getAttribute("href") 则返回原始值。
  • Playwright 添加了其专有的 CSS 伪类: div.product:has-text("Out of stock"), :text(),以及 :visible。其 CSS 还会穿透阴影根。这些功能在 Playwright 外部均无法使用。

Playwright 的官方文档建议使用用户可见的定位器,例如 getByRole() 和 getByTestId() ,而非使用 CSS 进行点击和表单输入操作,因为 CSS 会将测试与页面的具体实现绑定在一起。 对于读取重复的数据容器,CSS 仍是更实用的选择,因为产品网格中没有可访问性角色能将价格与标题区分开来。Playwright 的 CSS 定位器文档列出了所有扩展,而 Playwright 网络爬虫指南则涵盖了导航、等待和缩放等内容。

Selenium

Selenium 通过 By.CSS_SELECTOR 并在真实浏览器中执行,因此它能看到渲染后的DOM,并遵循矩阵中的浏览器列。 find_elements() 返回一个列表,若无匹配项则该列表为空,而 find_element() 则会抛出 NoSuchElementException. get_attribute("href") 则会抛出异常,并返回解析后的绝对 URL。

from selenium.webdriver.common.by import By

titles = driver.find_elements(By.CSS_SELECTOR, "div.product .title")
links = driver.find_elements(By.CSS_SELECTOR, "div.product a.link")
print([t.text for t in titles])                     # ['Blue Mug', 'Red Mug', 'Green Mug']
print([a.get_attribute("href") for a in links])     # ['https://shop.example.com/p/blue-mug', ...]

常见抓取任务的 CSS 选择器示例

大多数抓取任务都会重复几种模式:产品卡片、链接和分页、图片、表格以及标签-值对。下面的每种方案都提供了一个选择器以及一两行提取代码,首先使用标准 CSS,以确保该选择器在任何库中都能正常工作。

产品卡片和列表

先定位到商品卡片,再读取其中的字段。这样,如果某张卡片缺失价格,就不会导致后续所有价格被归入错误的记录中。尽可能在选择器层面进行过滤: div.product:not(.out-of-stock) 仅返回有库存的商品,以及 div.product:has(.badge) 无需二次遍历即可标记促销商品。

in_stock = [c.select_one(".title").get_text(strip=True)
            for c in soup.select("div.product:not(.out-of-stock)")]
# ['Blue Mug', 'Red Mug']
on_sale = [t.get_text(strip=True) for t in soup.select("div.product:has(.badge) .title")]
# ['Blue Mug']

这种“先卡片后字段”的模式是大规模追踪竞争对手价格的核心,通过这种方式,一个商品列表页面可以转化为数十行结构清晰的记录。

链接与分页

首先查找 a[rel="next"] 。 rel="next" 是一种许多网站使用的标准 HTML 链接类型,通常也是页面上最稳定的分页钩子。当网站未对其进行标记时,请使用“下一兄弟节点”组合子从当前页面跳转: .pager li.active + li a。href 通常是相对路径,因此在发送请求前需将其转换为当前页面的绝对路径。

next_href = response.css('a[rel="next"]::attr(href)').get()
# '?page=3'
next_url = response.urljoin(response.css(".pager li.active + li a::attr(href)").get())
# 'https://shop.example.com/mugs?page=3'

图片和延迟加载的资源

采用懒加载的页面通常会在 src 中,并将真实图片放置在 data-src中,脚本会在滚动时将其替换为真实图片。原始 HTML 解析器只能看到占位符,因此请先读取 data-src ,并回退到 src。响应式图片还可能在 srcset中,或将其包裹在 picture source 元素中,因此当需要最大尺寸的文件时,请同时检查这两者。

const images = $("div.product img").map((i, el) => $(el).attr("data-src") ?? $(el).attr("src")).get();
// [ '/img/a1.jpg', '/img/b2.jpg' ]

使用 img[data-src] 来仅查找延迟加载的图片,并 img:not([data-src]) 用于筛选其余图片。

HTML 表格

:nth-child() 可处理大部分表格相关工作。 tr:nth-child(n+2) 跳过表头行,而 td:nth-child(2) 选取第二列。不过,列的位置比表头标签的变化更为频繁。对于超出快速处理范围的任务,请先读取表头行一次,并将每个单元格映射到其表头名称。

values = [td.get_text(strip=True)
          for td in soup.select("table.specs tr:nth-child(n+2) td:nth-child(2)")]
# ['300 g', 'Blue']
headers = [th.get_text(strip=True) for th in soup.select("table.specs tr:first-child th")]
rows = [dict(zip(headers, [td.get_text(strip=True) for td in tr.select("td")]))
        for tr in soup.select("table.specs tr:has(td)")]
# [{'Name': 'Weight', 'Value': '300 g'}, {'Name': 'Color', 'Value': 'Blue'}]

标签与值对

定义列表和规格块将标签与其后面的值配对。 dt + dd 返回每个值,而 dt:has(+ dd) 返回每个实际具有值的标签。并行读取它们,并将其压缩为一个字典。带有 th 标签和一个同级 td 的表格,其工作原理与 th + td.

labels = response.css("dl.details dt:has(+ dd)::text").getall()   # ['Material', 'Capacity']
values = response.css("dl.details dt + dd::text").getall()        # ['Stoneware', '350 ml']
specs = dict(zip(labels, values))

当你需要“标签为 Capacity 的那个值”时,这就是文本匹配。标准 CSS 无法实现这一点,因此请使用 dt:-soup-contains("Capacity") + dd BeautifulSoup 中的,或者使用在任何地方都有效的 XPath 表达式。

为什么我的 CSS 选择器返回空结果?

通常是因为你的爬虫获取的 HTML 并非你检查的页面。开发者工具显示的是 JavaScript 执行后的 DOM,而 HTTP 客户端获取的是原始的服务器响应。其他常见原因包括 iframe、阴影 DOM、经过哈希处理的类名、未转义的特殊字符,以及两个本应连接的类名之间存在空格。

症状

可能原因

解决方法

在开发者工具中有效,但在爬虫中为空

内容由 JavaScript 渲染

检查“查看源代码”。查找页面调用的 JSON 或 XHR 请求,或在浏览器中渲染该页面。

仅在某些页面或某些国家/地区显示为空

页面变体不同、出现同意墙或验证页面

记录状态码并保存响应正文,以查看实际获取的内容

.product .card 未返回任何内容

一个空格将“both classes”转换为“descendant”

合并类: .product.card

包含冒号或以数字开头的 ID 会导致失败

未转义的特殊字符

对其进行转义(#a\:b) 或使用属性选择器 ([id="123"])

该元素位于 iframe 内

该 iframe 是一个独立的文档

直接请求 iframe 的 src URL,或使用 Playwright 的 frameLocator()

该元素位于 Web 组件内

它位于阴影根中

Playwright 的 CSS 可以穿透阴影根。而原始 HTML 解析器无法访问它们。

文本来自 ::before 或 ::after 中的文本缺失

伪元素内容未出现在 DOM 中

请在属性或样式表中查找该值,或跳过该项

值中包含多余的空格或被拆分

原始文本节点包含缩进和换行符

请去除文本中的空格,或使用 get_text(strip=True)

某个值在一种情况下匹配,但在另一种情况下不匹配

属性匹配区分大小写

添加 i 标志: [data-sku="a1" i]

Scrapy 会抛出 ExpressionError 异常 *-of-type

Parsel 需要元素名称

添加标签: div.product:nth-of-type(2)

当修复程序进行渲染时,您无需自行运行浏览器集群。Browser API 可以渲染页面并等待您的选择器,使用 wait_for_css,随后返回 HTML 或提取的字段。其工作原理类似于请求与响应:你发送 URL 和指令,然后获取结果。这并非由你一步步操控的实时浏览器会话。

CSS 选择器与 XPath:何时该切换?

默认情况下请使用 CSS 选择器。它们更简洁、更易读,并且受到所有爬虫库和浏览器的支持。当您需要可移植的文本匹配、特定的祖先节点、跨整个文档的位置逻辑,或者处理 XML 文档时,请切换到 XPath。大多数生产环境中的爬虫都会混合使用这两种方法。

  • 文本匹配:XPath的 contains(text(), "Capacity") 在所有XPath引擎中均有效。CSS文本匹配则取决于具体库。
  • 祖先节点:XPath 可以通过 .. 或 ancestor:: 轴。 :has() 根据包含关系进行选择,而非根据距离。
  • 文档范围内的位置: (//div[@class="product"])[2] 计数范围涵盖整个页面,而非仅限于同级元素。
  • XML:带有命名空间的源和站点地图在XPath中更易于处理。

任务

CSS

XPath

第二张卡片的标题

div.product:nth-child(2) .title

(//div[contains(@class, "product")])[2]//h2

“容量”标签后的值

dt:-soup-contains("Capacity") + dd (仅限 BeautifulSoup)

//dt[text()="Capacity"]/following-sibling::dd[1]

如需更深入地了解其中的权衡,请阅读关于 XPath 和 CSS 选择器的完整对比分析。

如何通过 API 运行 CSS 选择器?

将选择器随请求一并发送,即可返回 JSON 字段而非原始 HTML。WebScrapingAPI 的 Scraper API 接受一个 extract_rules 将字段名称映射到 CSS 或 XPath 选择器的对象。该 API 会在获取的页面上执行这些选择器(在您请求时通过 JavaScript 渲染),并返回文本、HTML、属性值或表格数据。

当难点在于数据抓取而非选择器编写时,此方法尤为有用。如果某个网站阻止您的请求、使用 JavaScript 渲染内容,或者根据国家/地区显示不同的结果,您可以保留已编写的选择器,并将数据抓取任务移交给 Scraper API 的提取规则。

每条规则将一个输出键映射到一个选择器字符串,或映射到一个包含以下键的规则对象:

  • selector: 一个 CSS 选择器或一个 XPath 表达式。
  • selector_type: css 或 xpath。若省略该参数,以 / 的选定符将被视为XPath,其余情况则视为CSS。
  • output: text ,或 html, @attr (例如 @href), table_json, table_array,或一个嵌套的规则对象。
  • all: 1 返回所有匹配项,而 0 仅返回第一个匹配项。
  • clean: 1 会从文本中去除首尾的空白和换行符。

extract_rules 将作为字符串化的 JSON 对象发送,因此需对其进行 URL 编码:

curl --get "https://api.webscrapingapi.com/v2" \
  --data-urlencode "api_key=$WSA_API_KEY" \
  --data-urlencode "url=https://shop.example.com/mugs?page=2" \
  --data-urlencode 'extract_rules={"titles":{"selector":"div.product .title","output":"text","all":1}}'

嵌套规则会先选择每张卡片,再选择其中的字段,其模式与上文的四层堆叠代码相同:

import json, os, requests

rules = {
    "products": {
        "selector": "div.product",
        "all": 1,
        "output": {
            "name": {"selector": ".title", "output": "text", "clean": 1},
            "price": {"selector": ".price", "output": "text", "clean": 1},
            "url": {"selector": "a.link", "output": "@href"},
        },
    }
}
response = requests.get("https://api.webscrapingapi.com/v2", params={
    "api_key": os.environ["WSA_API_KEY"],
    "url": "https://shop.example.com/mugs?page=2",
    "render_js": 1,
    "extract_rules": json.dumps(rules),
}, timeout=60)
print(response.json()["products"])

在规则中使用标准 CSS,并让 output 处理文本和属性。像 ::text 或 :-soup-contains() 等库扩展属于各自的库。API 会执行您发送的规则。您仍然负责选择器、输出模式以及检查每个字段是否正确的验证逻辑,并且当网站标记发生变化时,由您更新规则。

FAQ

哪些 CSS 选择器对网页抓取最有用?

类选择器、属性选择器(例如 [data-id] 以及 a[href^="/product"],后代和子元素组合符, :nth-child() 用于表格和列表的,以及 :has() 根据容器内容选择容器的选择器。这些选择器综合起来可满足大多数数据提取需求。库的扩展功能可处理文本和属性值。

如何使用 CSS 选择器获取文本或属性?

标准 CSS 选择的是元素,而非其文本或属性,因此每个库都会增加一个步骤。在 Scrapy 中,请使用 ::text 或 ::attr(href)。在 BeautifulSoup 中,调用 get_text() 或阅读 tag["href"]。在 Cheerio 中,使用 .text() 和 .attr()。在 Playwright 中,使用 innerText() 或 getAttribute().

CSS 选择器能否选择父元素?

可以。 :has() 伪类是根据元素的内容来选择元素的,因此 .card:has(.sale) 会返回带有“促销”徽章的卡片,而 :has(> .sale) 并将范围限定为直接子元素。现代浏览器、BeautifulSoup、Scrapy 和 Cheerio 均支持此功能。若需向上遍历固定层级数,请使用 XPath。

CSS 选择器能否根据元素的文本内容进行匹配?

在标准 CSS 中不行。库会添加自己的扩展: :-soup-contains() 在 BeautifulSoup 中, :contains() 在 Cheerio 和 Scrapy 的 Parsel 中,以及 :has-text() 在 Playwright 中。这些功能不具备跨平台兼容性,且会被浏览器拒绝。若需实现跨工具通用的文本匹配,请使用 XPath 配合 contains(text(), "…").

nth-child 和 nth-of-type 之间有什么区别?

:nth-child(2) 匹配其父元素的第二个子元素,无论其标签为何。 :nth-of-type(2) 匹配该父元素内部具有相同标签的第二个同级元素。在 Scrapy 和 Parsel 中, *-of-type 伪类需要标签名,因此应写成 div.item:nth-of-type(2),而不是 .item:nth-of-type(2).

为什么我的 CSS 选择器在 DevTools 中有效,但在爬虫中却无效?

开发者工具显示的是 JavaScript 执行后的页面,但 HTTP 客户端接收的是服务器发送的原始 HTML。如果“查看源代码”中不包含目标文本,说明内容是在客户端渲染的。请查找底层的 JSON 请求,在无头浏览器中渲染页面,或者使用在提取数据前会先进行渲染的 API。

网络爬虫应该使用 CSS 选择器还是 XPath?

建议从 CSS 选择器开始。它们更简洁、更易读,且在任何地方都受支持。当需要跨平台的文本匹配、特定的祖先元素或处理 XML 时,再切换到 XPath。许多爬虫会混合使用这两种方法,而 Scrapy 和 Parsel 允许你在同一个响应中同时使用它们。

应该先学习哪些 CSS 选择器?

先从类名和属性开始定位元素,然后学习空格和 > 组合符来限定容器范围。再学习 :nth-child() 用于处理表格和列表,以及 :has() 用于根据容器内容选择容器。接着学习所用库如何解析文本和属性,无论是 ::text, get_text(),还是 .text()。掌握这五种方法后,你就能编写和修复爬虫所需的几乎任何选择器。

无需运行爬虫即可测试选择器

向 Scraper API 发送 URL 和你的 CSS 选择器,即可获取经过清理的 JSON 字段,并在需要时通过 JavaScript 进行渲染。起始配额为 5,000 次免费请求。JavaScript 渲染或地理定位不会额外消耗配额,且失败的请求不会计费。

查看 Scraper API 定价

关于作者

Ștefan Răcilă, 全栈开发工程师 @ WebScrapingAPI

Ștefan Răcilă

全栈开发工程师

Stefan Racila 是 WebScrapingAPI 的 DevOps 及全栈工程师,负责开发产品功能并维护确保平台稳定运行的基础设施。

开始构建

准备好扩展您的数据收集规模了吗?

加入2,000多家企业,使用WebScrapingAPI在无需任何基础设施开销的情况下,以企业级规模提取网络数据。