site:example.com

import requests
import xml.etree.ElementTree as ET
from urllib.parse import urljoin

SM_NS = "{http://www.sitemaps.org/schemas/sitemap/0.9}"
HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def walk_sitemap(url, seen=None):
    """返回从网站地图或网站地图索引可到达的每个页面URL。"""
    seen = seen if seen is not None else set()
    if url in seen:          # 防止一个自引用的网站地图
        return []
    seen.add(url)

    resp = requests.get(url, headers=HEADERS, timeout=30)
    resp.raise_for_status()
    root = ET.fromstring(resp.content)
    tag = root.tag.split("}")[-1]   # 去掉命名空间，保留"sitemapindex"或"urlset"

    urls = []
    if tag == "sitemapindex":
        # 索引指向子网站地图 — 遍历每一个。
        for sm in root.findall(f"{SM_NS}sitemap"):
            loc = sm.findtext(f"{SM_NS}loc")
            if loc:
                urls.extend(walk_sitemap(loc.strip(), seen))
    else:
        # urlset直接列出页面URLs。
        for u in root.findall(f"{SM_NS}url"):
            loc = u.findtext(f"{SM_NS}loc")
            if loc:
                urls.append(loc.strip())
    return urls

if __name__ == "__main__":
    pages = walk_sitemap("https://example.com/sitemap.xml")
    print(f"从网站地图树发现 {len(pages):,} 个URLs")
    for u in pages[:10]:
        print(" ", u)

import requests
from urllib.parse import urljoin

HEADERS = {"User-Agent": "Mozilla/5.0 (sitemap-discovery)"}

def sitemaps_from_robots(base_url):
    """提取robots.txt中声明的每个Sitemap:指令。"""
    resp = requests.get(urljoin(base_url, "/robots.txt"), headers=HEADERS, timeout=30)
    resp.raise_for_status()
    sitemaps = []
    for line in resp.text.splitlines():
        if line.lower().startswith("sitemap:"):
            sitemaps.append(line.split(":", 1)[1].strip())
    return sitemaps

if __name__ == "__main__":
    for sm in sitemaps_from_robots("https://example.com"):
        print("声明的网站地图:", sm)

import requests
from collections import deque
from html.parser import HTMLParser
from urllib.parse import urljoin, urldefrag, urlparse
from urllib.robotparser import RobotFileParser

HEADERS = {"User-Agent": "Mozilla/5.0 (link-discovery)"}

class LinkParser(HTMLParser):
    """从页面中的<a>标签收集每个href。"""
    def __init__(self):
        super().__init__()
        self.links = []
    def handle_starttag(self, tag, attrs):
        if tag == "a":
            for key, value in attrs:
                if key == "href" and value:
                    self.links.append(value)

def load_robots(base_url):
    rp = RobotFileParser()
    rp.set_url(urljoin(base_url, "/robots.txt"))

rp.read()           # 解析不允许的规则和任何爬行延迟
    return rp

def crawl(start_url, max_pages=200, user_agent="*"):
    """遵守 robots.txt 的内部链接广度优先遍历。"""
    host = urlparse(start_url).netloc
    robots = load_robots(start_url)

    seen = {start_url}
    queue = deque([start_url])
    found, skipped = set(), []

    while queue and len(found) < max_pages:
        url = queue.popleft()

        # 合规检查：绝不会获取网站禁止的路径。
        if not robots.can_fetch(user_agent, url):
            skipped.append(url)
            continue

        try:
            resp = requests.get(url, headers=HEADERS, timeout=30)
            resp.raise_for_status()
        except requests.RequestException:
            # 单个错误的 URL 被记录在带外，不被追逐。
            continue
        if "text/html" not in resp.headers.get("Content-Type", ""):
            continue

        found.add(url)

        parser = LinkParser()
        parser.feed(resp.text)
        for href in parser.links:
            absolute = urldefrag(urljoin(url, href))[0]   # 解析并删除 #fragment
            if urlparse(absolute).netloc == host and absolute not in seen:
                seen.add(absolute)
                queue.append(absolute)

    return found, skipped

if __name__ == "__main__":
    pages, disallowed = crawl("https://example.com/", max_pages=200)
    print(f"发现 {len(pages):,} 页; 跳过 {len(disallowed)} 个被 robots.txt 禁止的页面")

对一个静态示例目录进行这个爬虫的实时运行发现了 40 个页面，限制设置为 40，且没有跳过任何 URL，因为该站点的 `robots.txt` 不禁止任何内容。指向一个 `robots.txt` 禁止某路径的站点时，爬虫正确拒绝了被禁止的 URL，并将其记录在 `skipped` 列表中，而不是抓取 — 在每个 URL 上都强制执行合规，而不是事后考虑。

这与早期的方法结合的方式：

- **爬虫找到服务地图忽略的内容；** 服务地图找到爬虫无法通过链接访问的内容。将两者结合并取并集以获得最完整的清单。
- **失败保持在带外。** 一个发生错误的 URL 会在此传递中被丢弃，而爬行会继续进行 — 一个错误页面不会延迟整个遍历。分别收集丢弃的 URL 以供审查。
- **限制并发以保持礼貌。** 像上面的单线程爬虫已经很温和了。如果并行化，保持每个主机 **最多 3 个工作线程**，并遵循任何 `robots.txt` 声明的 `Crawl-delay`。
- **爬虫仅处理 HTML。** 加载后由 JavaScript 绘制的链接对 `requests` 是不可见的。这个缺口正是第 6 种方法解决的。

---

## 方法 6 — 使用无损抓取浏览器渲染 JavaScript 重的页面

基于 `requests` 的爬虫读取服务器发送的任何字节。对于单页面应用、无限滚动目录或 React/Vue/Next.js 导航，这些字节是一个应用外壳 — `<div id="root"></div>` 加上一个脚本标签 — 一旦捆绑包运行，内部链接将客户端绘制。普通的 HTTP 无法看到它们；真实的浏览器可以。

无损抓取浏览器在云浏览器中渲染页面，并通过 Chrome DevTools 协议将其暴露。你通过 WebSocket 端点与 Playwright 连接，预热主页以便会话携带 cookies，导航到目标，然后从水合的 DOM 中收集锚点 — 这在第 5 种方法中是链接解析步骤的渲染页面对应物。美国出口固定在会话上，因此地理限制的网站提供其标准结构。

连接是由你的 API 密钥构建的单个 WebSocket URL。这个连接形状如下：

```python
import os
from urllib.parse import urlencode
from playwright.sync_api import sync_playwright

def scraping_browser_url(proxy_country="US", session_ttl=240):
    params = urlencode({
        "token": os.environ["SCRAPELESS_API_KEY"],
        "sessionTTL": session_ttl,
        "proxyCountry": proxy_country,
    })
    return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

from urllib.parse import urljoin, urldefrag, urlparse

def discover_rendered_links(start_url, proxy_country="US"):
    """在云浏览器中渲染一个 JS 重的页面并收集同主机链接。"""
    host = urlparse(start_url).netloc
    homepage = f"{urlparse(start_url).scheme}://{host}/"

    with sync_playwright() as p:
        browser = p.chromium.connect_over_cdp(scraping_browser_url(proxy_country))
        context = browser.contexts[0] if browser.contexts else browser.new_context()
        page = context.pages[0] if context.pages else context.new_page()

        # 首先预热主页，使会话携带 cookie，然后导航到目标。
        page.goto(homepage, wait_until="domcontentloaded", timeout=60_000)
        page.goto(start_url, wait_until="networkidle", timeout=60_000)

    hrefs = page.eval_on_selector_all(
        "a[href]", "els => els.map(e => e.getAttribute('href'))"
    )
    browser.close()

links = set()
for href in hrefs:
    if not href:
        continue
    absolute = urldefrag(urljoin(start_url, href))[0]
    if urlparse(absolute).netloc == host:
        links.add(absolute)
return links

使其可靠的模式：

- **先热身主页，然后导航。** 第一个 `goto` 到 `/` 让会话获取 Cookie 并通过站点的首次加载检查；第二个 `goto` 落在你真正想要枚举的页面上。在冷会话中直接访问深层 URL 更可能会引发挑战。
- **在目标上使用 `wait_until="networkidle"`** 给客户端路由器留出时间在你读取 DOM 之前挂载其链接。对于无限滚动页面，在循环中滚动到底部（`page.mouse.wheel`），直到链接数量停止增长，然后收集。
- **渲染在 Scrapeless 的云中进行，** 而不是在你的机器上。本地的 `playwright install chromium` 只是与 `wss://browser.scrapeless.com/...` 端点通信的 CDP 客户端。
- **将结果反馈到并集中。** 渲染的链接加入站点地图集合和静态抓取集合；通过标准化 URL 对合并集合进行去重，以便形成最终清单。

要将此集成到完整的抓取器中，将方法 5 中的 `requests.get` 内容替换为 `discover_rendered_links`，处理你知道基于 JavaScript 的主机，并保持廉价的 `requests` 路径以处理服务器渲染的多数。这样的 HTTP-优先、浏览器-次要的分割将云浏览器的使用限制在真正需要的页面上。

---

## 你得到的结果

每个方法都会输出一组绝对 URL；最终清单是它们的去重联合。同一个主机的合并记录如下所示：

```json
// 架构反映了四个编程方法的联合。
// 数量是示例样本，并非任何网站的固定快照。
{
  "host": "example.com",
  "discovered_at_methods": ["sitemap", "robots", "bfs_crawl", "rendered"],
  "counts": {
    "from_sitemap": 226,
    "from_bfs_crawl": 40,
    "from_rendered": 18,
    "union_unique": 248
  },
  "sample_urls": [
    "https://example.com/",
    "https://example.com/blog",
    "https://example.com/blog/how-to-scrape-bbb-business-listings",
    "https://example.com/app/catalog?page=2"
  ],
  "skipped_by_robots": [
    "https://example.com/private/"
  ]
}