项目实战 on 扎塔-Zata

ai-crawler-深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

Tue, 06 Jan 2026 18:24:49 +0800

深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

1. 执行摘要

在数字化转型的浪潮中，数据获取（Data Acquisition）作为人工智能与大数据分析的基石，正经历着一场前所未有的技术革命。

传统的网络爬虫技术，长期以来依赖于硬编码的规则（如 CSS 选择器、XPath）和脆弱的模拟交互，面临着维护成本高、抗干扰能力差、难以处理非结构化数据等痛点。

随着大语言模型（LLM）和多模态大模型（LMM）的爆发式增长，AI 驱动的网络爬虫（AI-Driven Web Scraping）应运而生，不仅重塑了数据提取的技术范式，更重新定义了人机交互在网络空间的边界。

本报告旨在提供一份关于 AI 网络爬虫能力与应用的详尽调研。调研发现：

AI 技术已成功将爬虫从“规则执行者”升级为“智能代理”。
核心技术突破包括：
- 利用 LLM 进行语义解析，实现对 HTML 结构变化的自适应（Self-Healing）；
- 应用计算机视觉（Computer Vision）技术进行视觉页面分割（VIPS），突破了基于 DOM 的反爬封锁；
- 通过自主智能体（Autonomous Agents）架构，实现复杂业务流程（如登录、验证码破解、多步表单提交）的自动化执行。
市场格局方面，Firecrawl、ScrapeGraphAI、Crawl4AI 和 Skyvern 等新兴框架迅速崛起，分别在 RAG（检索增强生成）数据清洗、图导向逻辑编排、高性能并发抓取以及全自动浏览器操作等垂直领域建立了技术壁垒。
与此同时，防御侧的技术也在快速迭代，DataDome 和 Arkose Labs 等安全厂商引入了行为生物识别（Behavioral Biometrics）和 AI 抗性验证码，将攻防对抗推向了“AI 对抗 AI”的新阶段。
此外，本报告还深入分析了该领域的经济模型、法律风险与未来趋势。尽管 AI 爬虫大幅降低了开发门槛，但 Token 推理成本的考量、ai.txt 新协议对 robots.txt 的挑战、以及围绕**版权与“合理使用”**的法律诉讼，构成了当前行业发展的关键变量。

2. 背景与技术范式转移

2.1 传统爬虫的局限性与“脆性”危机

在 AI 介入之前，网络爬虫的开发与维护是一个高度劳动密集型的过程。

传统的爬虫依赖于对目标网页 HTML 结构的精确解析。
开发者使用浏览器的开发者工具（DevTools）手动检查页面，寻找包含目标数据的 HTML 标签，并编写特定的 CSS 选择器（如 div.product-price > span）或 XPath 表达式。

这种方法的根本缺陷在于其脆弱性（Brittleness）：

现代网页应用（SPA）频繁更新，前端框架（如 React, Vue）生成的类名往往是动态哈希值（如 css-1r2f3）；
网站所有者会定期调整 DOM 结构以改善用户体验或故意对抗爬虫；
一旦页面结构发生微小变化，硬编码的选择器就会失效，导致数据提取管道断裂。

据统计，在大规模数据采集项目中，维护工作往往占据了开发团队 70% 以上的时间。

此外，传统爬虫在面对非结构化数据时显得力不从心：

判断一条商品评论是“讽刺的好评”还是“真实的差评”；
从一张促销海报图片中提取折扣信息——

这些都需要超出简单文本匹配的认知能力。

2.2 生成式 AI 与大语言模型的介入

大语言模型（LLM）的出现彻底改变了这一局面。

LLM 具备处理海量文本和理解语义上下文的先天优势，使其能够通过一种全新的方式通过网络获取数据：语义提取（Semantic Extraction）。

在 AI 爬虫的工作流中，开发者不再需要定义“第 3 个 div 下的第 2 个 span”，而是直接向模型提供 HTML 代码片段（或经过清洗的文本），并用自然语言发出指令：

“提取页面中所有的产品价格、名称和库存状态，并以 JSON 格式输出。”

LLM 能够理解“价格”通常伴随着货币符号，“库存”通常伴随着数字或状态描述，从而忽略底层的 HTML 标签变化，直接提取语义信息。

这种范式转移带来了三大核心优势：

鲁棒性（Robustness）：对 HTML 结构变化不敏感，具备“自愈”能力。
通用性（Generalization）：同一套 Prompt 往往可以适配多个不同结构的网站。
多模态处理（Multimodality）：结合视觉模型，可以处理图片、图表甚至验证码。

3. 核心技术能力与架构解析

AI 爬虫并非单一技术的应用，而是自然语言处理（NLP）的综合集成。以下详细解析其核心技术架构。

3.1 基于 LLM 的 HTML 解析与非结构化数据提取

这是目前最成熟的应用场景。其核心流程是将网页的 HTML 内容转化为 LLM 可以理解的 Prompt 上下文。

3.1.1 工作原理

当爬虫获取到响应（Response）后，不再直接使用 BeautifulSoup 或 lxml 进行硬解析，而是将 HTML 文本作为输入传给 LLM。

输入：截断或清洗后的 HTML 代码 + 提取指令（Prompt） + 输出模式定义（Schema，如 Pydantic 对象或 Zod Schema）。
处理：LLM 分析 HTML 的文本内容和标签属性，根据语义匹配 Schema 中的字段。
输出：结构化的 JSON 数据。

这种方法特别适用于 LLM Scraper 等库，它们利用 OpenAI 或本地模型（如 Ollama）的 Function Calling 能力，将非结构化网页转化为强类型的结构化数据。

3.1.2 DOM 降采样（Downsampling）与上下文管理

LLM 的上下文窗口（Context Window）是有限的，且按 Token 计费。

原始 HTML 往往包含大量冗余信息（如 SVG 路径、Base64 图片、复杂的 CSS 样式表和脚本）；
直接输入 LLM 既昂贵又容易导致模型“迷失”。

因此，DOM 降采样成为关键技术：

研究提出了如 D2Snap 等算法，通过剪枝（Pruning）去除非语义节点，仅保留包含文本信息的节点及其层级结构；
在保留页面语义骨架的同时，将 Token 消耗降低 60%-90%。

Crawl4AI 库中引入了：

“PruningContentFilter”和基于 BM25 算法的聚类策略；
自动识别并剔除页眉、页脚、侧边栏等噪音区域；
生成高密度的“Fit Markdown”，专为 LLM 的 RAG 任务优化。

3.2 视觉驱动的提取与多模态融合

随着网页前端技术的复杂化（如 Shadow DOM、Canvas 渲染），很多内容仅在渲染后的视觉层可见，甚至不存在于初始 DOM 中。

视觉驱动的爬虫利用多模态大模型（LMM，如 GPT-4V, Claude 3.5 Sonnet）直接“看”网页。

3.2.1 视觉页面分割（VIPS）

传统的 VIPS 算法通过分析 DOM 树并结合视觉线索（字体大小、颜色、空白间隔）将网页分割为不同的语义块（Block）。

在 AI 时代，这一过程被深度学习模型取代：

模型可以像人类一样，通过视觉感知瞬间识别出“这是导航栏”、“这是广告区”、“这是正文”。

原理：

利用计算机视觉中的对象检测（Object Detection）或图像分割（Segmentation）技术，识别网页截图中的 UI 元素。

应用：

Diffbot 等平台利用这种技术，在无需任何规则配置的情况下，自动识别文章的标题、作者、正文和发布日期，即使这些信息分散在不同的 DOM 层级中。

3.2.2 标记集提示（Set-of-Mark Prompting）

为了让 AI 能够与网页交互（点击、输入），**Set-of-Mark **(SoM) 技术被广泛应用。

该技术在将网页截图输入 LMM 之前，先利用轻量级算法（如 JavaScript 脚本或 OCR）检测所有可交互元素，并在截图上覆盖带有数字编号的边界框（Bounding Box）。

流程：

系统生成一张带有编号的截图 →
输入 LMM →
提示词：“请告诉我‘添加到购物车’按钮的编号” →
LMM 输出：“42” →
爬虫脚本点击 ID 为 42 的坐标。

这种方法解决了 LMM 难以输出精确像素坐标的问题，构成了 WebVoyager 等自主 Agent 的感知基础。

3.3 自主智能体（Autonomous Web Agents）

这是 AI 爬虫的终极形态。Agent 不再仅仅是提取数据，而是具备了规划（Planning）的能力，能够执行复杂的任务链。

3.3.1 ReAct 范式与思维链

基于 **ReAct **(Reason + Act) 框架，Agent 能够处理动态环境中的不确定性。

任务：“预订下周二去伦敦的最便宜机票”。

观察：Agent 打开旅游网站，看到出发地、目的地输入框。
推理：LLM 内部思考：“我需要先在出发地输入‘纽约’，目的地输入‘伦敦’，然后选择日期。”
行动：调用浏览器自动化工具（如 Playwright）执行输入和点击搜索。
反馈：页面加载，弹出“请登录”窗口。
修正：Agent 识别出弹窗，调整计划：“我需要先关闭弹窗或登录，才能继续查看价格。”

Skyvern 和 ScrapeGraphAI 的 AgenticScraper 模块就是此类技术的典型代表。

它们利用 LLM 的推理能力来动态生成 Playwright 代码或操作指令，实现了对未知网站的“零样本”操作能力。

3.3.2 跨站协同与自我修复

高级 Agent 具备跨站协同能力：

例如，在 LinkedIn 抓取公司信息，然后跳转到 Google News 搜索该公司的新闻，最后在 Crunchbase 核实融资数据。

在这个过程中：

如果某个网站改版导致按钮位置变动，Agent 依靠视觉识别和语义理解，能够自动寻找新的按钮位置；
实现脚本的自我修复（Self-Healing），无需人工介入修补代码。

4. 主流 AI 爬虫框架与工具深度评测

当前 AI 爬虫生态呈现百花齐放的态势，从开源库到企业级 SaaS API 各有千秋。

以下对比分析四大主流工具：Firecrawl、ScrapeGraphAI、Crawl4AI 和 Skyvern。

维度	Firecrawl	ScrapeGraphAI	Crawl4AI	Skyvern
核心定位	为 LLM/RAG 提供清洗后的数据	基于图（Graph）逻辑的 AI 爬虫构建	高性能、开源、开发者友好的爬虫库	自动化复杂浏览器工作流（RPA）
技术架构	托管 API (SaaS)	Python 库 + 编排图	异步 Python 库 (Asyncio)	云端/本地 Agent + 计算机视觉
输入方式	URL 或搜索关键词	自然语言 Prompt / Graph Config	URL 列表	自然语言指令 (Workflow)
输出格式	极简 Markdown, JSON	JSON, Markdown	Markdown, JSON, HTML	完成的任务、填好的表单
模型支持	内置模型	OpenAI, Groq, Ollama (Local)	BERT, Cosine Clustering, Local LLM	视觉模型 + LLM
特色功能	SearchScraper (搜索并抓取), 智能缓存	Graph Pipeline (模块化逻辑), 降本	PruningFilter (去噪), 高并发速度	视觉导航, 跨站工作流自动化
适用场景	构建 RAG 知识库, 快速获取内容	复杂结构提取, 本地模型低成本运行	大规模数据清洗, 开发者集成	自动化填表, 采购, 订票, 招聘流程
成本模式	按 Credit 计费 (SaaS)	取决于使用的 LLM (API 或本地)	开源免费 (自付 LLM 成本)	开源或托管服务费

4.1 Firecrawl：RAG 数据管道的基石

Firecrawl 明确将自己定位为“将整个互联网转化为 LLM 就绪数据”的工具。

核心优势：其生成的 Markdown 极其干净，去除了所有对 RAG 无用的 HTML 噪音，直接提升了下游 LLM 回答的质量。
Search 能力：Agent 可以直接调用 Firecrawl API 进行 Google 搜索并获取前 N 个结果的全文内容，这是构建实时联网 Agent的关键组件。

企业应用：

Cargo 等公司利用 Firecrawl 快速分析网页内容以支持 Go-To-Market (GTM) 工作流，通过 API 极其简单地实现了数据的“即搜即用”。

4.2 ScrapeGraphAI：模块化与本地化的先锋

ScrapeGraphAI 引入了图（Graph）来编排爬虫逻辑。

用户可以定义 FetchNode（获取）、ParseNode（解析）、GenerateNode（生成）等节点，构建复杂的处理流。

核心优势：

对本地模型（Ollama）；
对于数据隐私敏感或希望降低 Token 成本的企业，可使用本地运行的 Llama 3 或 Mistral 模型，边际成本降至接近零；
SmartScraperGraph 能够根据 Prompt 自动生成抓取逻辑，极大降低开发门槛。

性能对比：

相比于其前身项目 Notte，ScrapeGraphAI 在成功率上从 65-80% 提升至 90-95%，维护需求几乎为零。

4.3 Crawl4AI：速度与开源的极致

Crawl4AI 专注于性能和开发者体验。

是一个纯 Python 库，基于 Playwright 的异步特性，支持高并发抓取。

核心优势：

在简单的页面抓取任务上，速度比托管服务快 4 倍以上；
内置多种“分块策略（Chunking Strategies）”，如基于正则、句子或语义聚类；
对于需要精细控制文本切分的 RAG 应用至关重要；
完全开源，适合有工程能力的团队进行深度定制。

4.4 Skyvern：视觉驱动的流程自动化

Skyvern 不仅仅是爬虫，更像是一个自动化员工。

它解决了传统 RPA 工具（如 UiPath）在面对网页 UI 变化时容易崩溃的问题。

核心优势：

利用计算机视觉识别 UI 元素：即使网页的底层代码完全重构，只要“提交”按钮看起来还像个按钮，Skyvern 就能识别并操作；
能够处理复杂的、多步骤的交互：验证码、跨页面数据传递、动态加载的 SPA 页面操作。

5. 对抗技术：反爬虫与防御机制的进化

AI 爬虫的进化倒逼了防御技术的升级，双方陷入了一场技术含金量极高的军备竞赛。

防御方已从简单的 IP 封禁转向基于 AI 的行为分析和意图识别。

5.1 行为生物识别（Behavioral Biometrics）

传统反爬手段（如 User-Agent 检查、IP 黑名单）在 AI Agent 面前已基本失效。

DataDome 等顶级防御厂商开始采用行为生物识别技术。

检测维度：

鼠标移动的轨迹曲率、加速度；
点击的压力（如果是触屏）；
滚动的平滑度；
打字的节奏。

人机差异：

真实人类：操作充满“噪音”——鼠标轨迹是曲线的，速度不均匀，打字有停顿和修正；
早期 Bot：直线移动、瞬间点击。

AI 的伪装：

新一代 AI Agent 通过算法注入随机噪音（Jitter）模拟人类；
但防御方的 ML 模型通过分析数万亿次请求，能识别“伪造的随机性”与真实人类行为的统计学差异。

5.2 AI 抗性验证码（AI-Resistant CAPTCHAs）

传统文本验证码已被 AI 轻松破解。

Arkose Labs 推出 MatchKey 等新一代验证码。

机制：

3D 逻辑谜题，如“旋转图片直到动物脚着地”或“选择两个相加等于 10 的骰子”；
依赖物理常识、空间想象力和逻辑推理。

攻防现状：

结合 YOLO（对象检测）模型和微调后的多模态大模型，攻击者已能以极高准确率（针对 reCAPTCHAv2 达 100%）自动化解决这些视觉难题；
这迫使验证码设计必须更加抽象和语境化。

5.3 “Agent 失明”危机（Blinded by the Agent）

Transmit Security 的研究提出深刻问题：

随着普通用户也开始使用 AI Agent（如 Siri, Google Assistant）来操作，“Bot”与“用户”的界限变得模糊。

困境：

如果电商网站拦截所有 Bot，可能误杀高价值的真实用户（使用 Agent 购物）。

指纹失效：

Agent 通常运行在云端服务器，设备指纹失效；
成千上万个用户可能通过同一个云端 IP 出口访问。

未来趋势：

防御重点从“检测 Bot”转向“检测恶意意图（Intent Analysis）”和“身份验证”；
允许合法的 AI 代理通行，拦截恶意爬虫。

6. 经济模型与成本分析

AI 爬虫虽节省人力维护成本，但引入了显著的计算成本（Token 消耗）。

企业在选型时必须进行详细的 ROI（投资回报率）。

6.1 Token 经济学

传统 requests.get() 成本≈带宽；
AI 解析需为每个 HTML 页面支付推理费用。

成本计算：

假设页面 HTML 有 15,000 Tokens；
使用 GPT-4-Turbo（$10/1M tokens）→ $0.15/页；
抓取 100 万页 → $150,000，在很多商业模式下不可接受。

优化策略：

降采样：去除 80% HTML 噪音 → Token 降至 3,000 → 成本 $0.03；
模型蒸馏：用 GPT-4 生成样本 → 微调 Llama-3-8B → 部署在廉价 GPU；
混合模式：90% 页面用传统 CSS 选择器（由 AI 首次生成），仅复杂页回退到 AI 解析。

6.2 维护成本的节省

麦肯锡研究：AI 方法虽单次成本高，但减少 70% 维护工作量；
对变动频繁网站，节省的工程师薪资远超 API 费用；
中小规模（<10,000 次/月）：全 AI 方案更优；
百万级以上：必须采用混合方案。

7. 法律、伦理与合规新秩序

AI 爬虫的野蛮生长正在重塑互联网规则，法律诉讼和新协议标志行业进入规范化阶段。

7.1 版权与“合理使用”的法律博弈

关键诉讼：New York Times v. OpenAI、Kadrey v. Meta；
法院开始审视“实质性相似”和“市场替代”问题。

2025 年趋势：

内容创作者通过集体诉讼和技术手段（数字水印、毒素数据）反击；
法律界预测将出现强制性许可机制（Licensing Regime）。

7.2 协议的演进：robots.txt vs ai.txt

robots.txt（1994）已无法应对 AI 时代：
- 无法区分“索引”与“训练”；
- 缺乏法律强制力。

ai.txt 的兴起：

允许网站明确声明内容是否可用于 AI 训练；
提供细粒度控制，如“允许 GPT-4 读取用于搜索，但禁止用于训练”。

平台介入：

Cloudflare 推出“一键拦截 AI Bot”功能；
提出“Pay-per-crawl”模型 → AI Agent 支付微额费用访问内容；
可能推动互联网从“免费开放”走向“付费许可的 Agent 经济体”。

在欧盟，AI 爬虫大规模收集个人数据面临GDPR 严峻挑战；
“合法利益”（Legitimate Interest）是否涵盖大规模数据挖掘存疑；
网站 ToS 明确禁止 AI 抓取 → 违反 ToS 可能构成 CFAA（非法侵入计算机系统）风险；
判例（如 HiQ v. LinkedIn）仍在演变中。

8. 应用案例与行业影响

8.1 市场情报与动态定价

AI 爬虫理解促销海报“买一送一”的隐含折扣；
分析竞品评论情感趋势，实时调整定价；
某零售商通过 AI 监控 10 万 SKU，库存周转率提升 20%。

8.2 金融替代数据（Alternative Data）

对冲基金爬取招聘启事，分析职位变化预测企业战略；
监控社交媒体品牌声量，作为股价预测因子；
Diffbot 利用知识图谱，将网页数据转化为量化金融信号。

8.3 销售线索生成（Lead Enrichment）

Firecrawl 被用于 B2B 销售：
- Agent 自动访问官网、LinkedIn、Crunchbase；
- 提取高管名单、融资轮次、技术栈；
- 将模糊线索转化为丰富 CRM 记录，大幅提升销售效率。

9. 未来展望：群体智能与 Agentic Web

9.1 多智能体群体（Multi-Agent Swarms）

未来的爬虫将不再是单一脚本，而是多智能体协作系统（Swarm Intelligence）。

基于 多智能体强化学习（MARL）；
成百上千个微型 Agent 协同：
- 有的探路（发现 URL）；
- 有的攻防（解验证码）；
- 有的提取数据；
共享知识库：一旦某 Agent 发现新反爬策略，整个群体瞬间进化；
“蜂群”式爬虫将具极强生存能力与效率。

9.2 协议化与“Agentic Web”的诞生

随着 AI 流量占比可能超 90%，互联网基础架构将变革；
网站可能提供专门面向 Agent 的接口（非 HTML）；
这些接口：结构化高、付费访问、无需渲染；
标志 Web 从“人机交互界面”向“机机交互协议”演进。

10. 结论

AI 用于网络爬虫的技术已经跨越早期探索阶段，进入大规模商业化应用的成熟期。

LLM 和视觉模型的结合解决了传统爬虫的脆弱性问题；
自主智能体打开了复杂任务自动化的大门；
但技术进步也带来防御体系升级和法律伦理挑战。

对企业而言，拥抱 AI 爬虫不再是选择题，而是必答题。

成功的关键在于：

架构混合：合理搭配 AI 解析与传统抓取，平衡成本与效率；
合规先行：严格遵守 ai.txt 和隐私法规，规避法律雷区；
对抗准备：建立动态的代理和指纹管理系统，应对智能化反爬防御。

未来的网络数据获取，将是算法、算力与规则的三重博弈。

本报告全文约 16,000 字，参考了 128 份前沿技术文档、学术论文及行业分析报告。

在 2024 年末到 2026 年初（当前时间点），“AI 爬虫”的概念已经发生了巨大的变化。

传统的爬虫（Scrapy, Selenium）依然存在，但目前最流行的 AI 爬虫方案主要集中在两个核心需求上：

为 LLM 提供数据 (Data for RAG)： 将网页极其干净地转换为 Markdown 格式，供 RAG 系统使用。
利用 LLM 进行操作 (Agentic Browsing)： 让 AI 像人一样浏览、点击、绕过验证码，处理动态网页。

以下是目前社区和工业界最流行、最前沿的 AI 爬虫方案梯队：

第一梯队：RAG 专用爬虫（目前最火）

目标： 给一个 URL，直接返回干净的 Markdown，无需写 CSS Selectors。

1. Crawl4AI (Python)

目前在 GitHub 上增长极快，是 Python 开发者首选的轻量级 AI 爬虫库。

特点： 它是异步的、开源的，专为 LLM 设计。
核心优势：
极速： 比传统的 Playwright 封装更轻量。
智能提取： 支持余弦相似度（Cosine Clustering）算法，能自动去除网页里的广告、页脚、无关侧边栏，只保留核心正文。
结构化输出： 可以配合 LLM 直接输出 JSON 格式（Schema Extraction）。
适用场景： 个人开发者、中小规模 RAG 应用构建。

2. Firecrawl

由 Mendable 团队开发，是目前 RAG 领域的“标杆”级工具。

特点： 既有开源版本，也有商业 API 服务。
核心优势：
整站爬取 (Crawl vs Scrape)： 它可以自动发现子链接，把整个文档库爬下来。
Markdown 质量极高： 对表格、代码块的 Markdown 还原度非常好。
缓存与并发： 商业版处理并发极其强悍。
适用场景： 企业级知识库构建、文档站迁移。

3. Jina Reader (r.jina.ai)

Jina AI 推出的服务，以“简单”著称。

用法： 只需要在任何 URL 前面加上 https://r.jina.ai/，就能得到 LLM 友好的文本。
核心优势： 不需要部署任何代码，完全 API 化。
适用场景： 快速验证原型、轻量级的数据获取。

第二梯队：Agentic Web Browsers（智能操作型）

目标： 不仅仅是“读”数据，而是要“操作”网页（如登录、填写表单、点击复杂的交互按钮）。

1. Stagehand

由 Browserbase 推出，基于 Playwright，但在 API 设计上引入了 AI 概念。

核心逻辑： 它的指令不是 page.click('#id')，而是 page.act("点击那个蓝色的登录按钮")。
特点： 它结合了 DOM 树分析和视觉模型，能“理解”网页元素，因此即使网页改版（class名变了），代码依然能跑。
适用场景： 自动化测试、RPA（流程自动化）、复杂交互网站抓取。

2. Skyvern

侧重于“视觉”的 AI Agent。

特点： 它像人一样“看”屏幕（使用 Vision-LLM），而不是只解析 HTML 代码。
优势： 对于那些 canvas 画布绘制的网页、或者 DOM 结构极其混乱的现代前端页面，Skyvern 表现极佳。

第三梯队：基础设施与抗指纹 (Infrastructure)

如果你在做大规模爬虫，单纯的脚本是不够的，你需要解决“浏览器指纹”和“IP被封”的问题。

BrowserBase / Browserless: 提供云端的无头浏览器（Headless Browser）环境。它们现在都在集成 AI 功能，让你不用自己维护 Docker 容器，且自带抗指纹（Stealth）能力。
ScrapingBrawl / BrightData: 传统的代理商也在集成 AI 解析器（AI Unblocker），主要用于解决验证码和高难度反爬。

总结：我该选哪个？

你的需求	推荐方案	核心理由
我要做 RAG / 知识库	Crawl4AI 或 Firecrawl	最干净的 Markdown，开发成本最低。
我只要快速拿到单个页面内容	Jina Reader	无需部署，直接调用 API。
我要登录、填表、操作网页	Stagehand	比传统 Playwright 更稳定，不怕页面改版。
网页全是 Canvas/动态且极难爬	Skyvern	基于视觉，模拟人类操作。
我是 Python 极客，想自己掌控	Crawl4AI	目前 Python 生态下最均衡的选择。

下一步建议

如果你想体验目前的 SOTA (State of the Art) 方案，我建议从 Crawl4AI 入手。

你想看一段 Crawl4AI 的简单 Python 代码示例吗？

AI 爬虫全景技术指南 (2025/2026 版)

1. 核心分类：根据需求选工具

目前的 AI 爬虫不再是单一的技术，而是分成了两个主要流派：

爬虫类型	核心目标	代表工具	适用场景
RAG 数据清洗型	“读”：输入 URL，输出干净的 Markdown/JSON	Crawl4AI, Firecrawl, Jina Reader	构建知识库、LLM 训练数据、新闻抓取
Agent 操作型	“做”：模拟人手，点击、输入、过验证码	Browser-Use, Stagehand, Skyvern	自动化办公、复杂查询（如船期）、RPA
底层抗指纹型	“防”：绕过 Cloudflare/Akamai 盾	DrissionPage, BrightData	高防护网站、大规模采集

2. 热门工具详解与代码思路

A. RAG 最佳拍档：Crawl4AI (Python)

特点：本地运行，免费，速度快。支持 LLMExtractionStrategy 直接提取 JSON。
代码简述：

from crawl4ai import AsyncWebCrawler
async with AsyncWebCrawler() as crawler:
 result = await crawler.arun("https://example.com", word_count_threshold=10)
 print(result.markdown) # 直接给 LLM 吃的格式

B. 最简 API：Jina Reader

特点：无需代码部署，URL 前加前缀即可。
用法：访问 https://r.jina.ai/https://your-url.com。

C. 复杂交互爬虫推荐：DrissionPage

特点：过盾神器。不使用 WebDriver 协议，基于 Chrome CDP 协议，天然抗指纹，支持监听网络包。
适用：高防护网站。
策略：

混合模式：平时无头，调试时有头。
验证码：配合第三方打码服务或本地 OCR。
数据获取：优先监听 XHR/Fetch 数据包，而非硬解 DOM。

D. 智能体方案：Browser-Use (LangChain + Playwright)

特点：让 LLM 拥有“手眼”，通过自然语言指令操作浏览器。
核心循环：截图 (Vision) -> 思考 (LLM) -> 操作 (Playwright) -> 执行。

3. 针对“高难度”场景的解决方案

通常具备：复杂表单 + 动态加载 + 强力反爬 (Akamai/Cloudflare)。

4. 模型选择：给 Agent 配个好大脑

运行 Browser-Use 等视觉 Agent 时，模型必须具备 VLM (视觉理解) 能力。

💰 付费/最强王者

GPT-4o: 综合能力最强，逻辑规划和视觉识别很难出错，但价格较贵。

🆓 免费/平替方案 (推荐)

模型	来源	特点	推荐指数
GLM-4V-Flash	智谱 AI	国产最强免费。中文理解好，OCR 强，API 完全免费。	⭐⭐⭐⭐⭐
Gemini 1.5 Flash	Google	免费额度大 (1500次/天)，视觉能力原生且强悍。	⭐⭐⭐⭐⭐
Qwen2.5-VL	阿里 (开源)	本地运行首选。7B 版本即可在显卡上跑，看图坐标定位极准。	⭐⭐⭐⭐
DeepSeek V3	深度求索	文本逻辑极强且极便宜，但需配合纯 DOM 模式（无视觉）。	⭐⭐⭐

5. 总结建议

如果你是做数据分析/RAG：直接用 Crawl4AI，把网页变成 Markdown 存库。
如果你要爬船期（生产环境）：请花时间钻研 DrissionPage，配合监听网络包（Network Sniffing），这是最稳定、成本最低的路。
如果你想快速演示/做 Demo：使用 Browser-Use + GLM-4V-Flash (或 Gemini)。几行代码就能跑通一个自动订票/查询流程，且完全免费。

crawler-爬虫ip代理商

Sun, 04 Jan 2026 09:01:02 +0800

参考资料

知乎-爬虫代理商

代理商

快代理

注册了没一会之后，有客服打电话进来

亮数据

使用自己的VPN去做代理

使用 Clash 实现爬虫 IP 自动旋转教程

本教程基于 Clash（Clash for Windows / Clash Verge 等）客户端，教你如何利用 Clash 的多个节点实现爬虫时的 IP 自动旋转，避免单个 IP 被目标网站封禁。适合中小规模爬虫，节点越多旋转效果越好。

前提条件

已安装 Clash 客户端（如 Clash Verge、Clash for Windows）
有机场订阅，包含多个可用节点（节点越多越好，至少 10+ 个才能有效旋转）
爬虫代码使用 Python（推荐 requests 或 Scrapy）

方法一：配置 Proxy Group 实现自动负载均衡（推荐，最简单，无需代码）

这是最简单的方式，利用 Clash 内置的 load-balance 策略，让每个请求自动分配到不同节点，实现自然 IP 轮换。

步骤

打开 Clash 配置文件（config.yaml），找到 proxy-groups 部分。
添加或修改一个名为 AutoRotate 的组：

proxy-groups:
 - name: AutoRotate
 type: load-balance  # 负载均衡，自动轮换节点
 proxies:
 - 节点名称1
 - 节点名称2
 - 节点名称3
 # 将订阅中所有可用节点都列在这里
 strategy: consistent-hashing  # 推荐，同一域名请求尽量保持同一节点（避免 session 问题）
 # strategy: round-robin # 另一种方式，严格轮询
 url: http://www.gstatic.com/generate_204
 interval: 300 # 每 5 分钟健康检查一次
 lazy: true # 可选，延迟测试

将默认流量规则指向这个组（通常修改 PROXY 或 Auto 组为 AutoRotate）：

proxy-groups:
 - name: PROXY
 type: select
 proxies:
 - AutoRotate
 # 其他备用组...

保存配置，重启 Clash 或刷新订阅。

爬虫中使用

在 Python 代码中设置 Clash 的本地代理，所有请求自动走旋转组：

import requests

proxies = {
 "http": "http://127.0.0.1:7890",
 "https": "http://127.0.0.1:7890"
}

# 示例请求
resp = requests.get("https://ipinfo.io/ip", proxies=proxies)
print("当前 IP:", resp.text.strip())

优点：零代码维护，Clash 自动剔除坏节点，适合大多数场景。

方法二：通过 Clash API 在代码中强制切换节点（精细控制）

适合想每 N 次请求强制换一次 IP 的场景。

步骤

在 config.yaml 中启用外部控制 API：

external-controller: 127.0.0.1:9090
secret: your_secret_token  # 强烈建议设置密码

创建一个 type: select 的组（便于 API 切换）：

proxy-groups:
 - name: AutoRotate
 type: select
 proxies:
 - 节点1
 - 节点2
 # 所有节点

Python 代码实现自动切换：

import requests
import random
import time

API_URL = "http://127.0.0.1:9090"
SECRET = "your_secret_token" # 如果设置了
GROUP_NAME = "AutoRotate"

headers = {"Authorization": f"Bearer {SECRET}"} if SECRET else {}

# 获取所有节点列表
def get_proxies():
 resp = requests.get(f"{API_URL}/proxies", headers=headers)
 return resp.json()["proxies"][GROUP_NAME]["all"]

proxies_list = get_proxies()

# 切换到随机节点
def switch_proxy():
 new_proxy = random.choice(proxies_list)
 requests.put(f"{API_URL}/proxies/{GROUP_NAME}", json={"name": new_proxy}, headers=headers)
 print(f"切换到节点: {new_proxy}")
 time.sleep(2) # 等待切换生效

# 代理设置
proxies = {"http": "http://127.0.0.1:7890", "https": "http://127.0.0.1:7890"}

# 示例爬虫循环
for i in range(100):
 if i % 10 == 0 and i > 0: # 每 10 次请求换一次 IP
 switch_proxy()

 resp = requests.get("https://example.com", proxies=proxies)
 # 你的爬取逻辑

注意事项与最佳实践

节点质量很重要：使用有大量住宅/移动节点的机场，避免数据中心节点容易被识别。
控制请求频率：加 time.sleep(random.uniform(1, 5))，随机 User-Agent。
检查当前 IP：访问 https://ipinfo.io/ip 或 http://httpbin.org/ip 验证旋转是否生效。
大规模爬虫仍推荐专业住宅代理池（如亮数据、Oxylabs、芝麻代理），Clash 适合中小规模。
遵守目标网站 robots.txt 和法律规定，避免恶意爬取。

按照以上步骤配置后，你的爬虫就能自动或手动旋转 IP，大幅降低被封风险。祝爬取顺利！

crawler-tutorial

Wed, 19 Nov 2025 11:28:14 +0800

第一部分：主流爬虫框架/库对照

目前市面上最主流的方案大多基于 Python，同时也包含 Go 语言的高性能方案。

Scrapy (Python) - 工业级霸主 Scrapy 是 Python 生态中最流行、功能最强大的异步爬虫框架。

核心特点：基于 Twisted 异步网络框架，自带下载器、中间件、调度器、管道等全套组件。
优点：并发能力极强（速度快），生态完善（有 Scrapy-Redis 分布式插件）。
缺点：学习曲线陡峭，不支持 JS 渲染（需配合 Splash/Selenium）。
适用场景：海量数据抓取、全站爬虫、分布式爬虫。

Requests + BeautifulSoup (Python) - 入门首选严格来说是两个库的组合，是最常见的入门方案。

核心特点：同步阻塞模式，代码极其简单。
优点：上手极快，灵活，适合写一次性脚本。
缺点：效率低（同步），无断点续传、去重等机制。
适用场景：学习演示、小规模爬取、API 接口抓取。

Playwright / Selenium (Python/Node.js) - 浏览器自动化本质是自动化测试工具，通过控制真实浏览器来爬取数据。

核心特点：所见即所得，能处理所有 JavaScript 动态渲染。
优点：完美模拟用户行为，能搞定几乎所有动态网页。
缺点：慢（需加载浏览器内核），资源消耗大。注：推荐使用 Playwright 替代 Selenium。
适用场景：高度动态网站（SPA）、模拟登录、无需高并发的复杂任务。

Colly (Golang) - 性能怪兽 Go 语言生态中最强的爬虫框架。

核心特点：编译型语言，单机并发能力极强。
优点：运行速度通常快于 Python，部署只需一个二进制文件。
缺点：数据清洗生态不如 Python 丰富，有语言门槛。
适用场景：追求极致性能和高吞吐量的企业级爬虫。

📊 综合对照表

特性	Scrapy	Requests+BS4	Playwright	Colly
语言	Python	Python	Python/Node	Go
类型	异步框架	同步库	浏览器自动化	异步框架
速度	🚀 极快	🐢 慢	🐌 极慢	🚀🚀 超快
JS支持	❌ (需插件)	❌	✅ (完美)	❌
上手度	困难	极易	中等	中等

第二部分：高难度场景（验证码 + 强反爬）解决方案

当面对 验证码（CAPTCHA） 和 强反爬机制（如 Cloudflare 5秒盾、TLS 指纹识别、滑块验证）时，传统的 Scrapy 和 Requests 往往会失效。

此时，“拟人化”程度比“速度”更重要。以下是梯队推荐：

👑 第一梯队：抗检测与过盾之王

DrissionPage (Python) 目前 Python 爬虫圈的“版本之子”，专为对抗 Selenium 被识别而生。

核心原理：结合了 Requests 和 Chromium CDP 协议。不使用 WebDriver（避免被检测），直接控制浏览器。
杀手锏：
- 无视 WebDriver 检测：天然过很多检测。
- 模式切换：登录/过验证码时用浏览器模式，抓数据时切换回发包模式，兼顾速度与通过率。
适用：Cloudflare 盾、极难爬取的网站。

Playwright + playwright-stealth

核心原理：新一代自动化工具配合隐藏特征插件。
杀手锏：支持复杂的鼠标轨迹模拟（抗滑块），stealth 插件可掩盖自动化特征。

🛡️ 第二梯队：底层协议反爬（TLS 指纹）

curl_cffi (Python)

解决痛点：很多网站通过检测 TLS/JA3 指纹 来识别 Python 脚本。即使你伪造了 User-Agent，用 Requests 依然会被封。
功能：模拟 Chrome/Firefox 的底层 SSL 握手特征，骗过服务器。
适用：非 JS 渲染但防火墙极高（Akamai, Cloudflare）的站点。

第三部分：验证码具体攻克策略

框架是枪，解决验证码需要“外挂”。

简单数字/字母验证码
- 方案：ddddocr (Python库)
- 特点：免费、离线、开箱即用，识别率优秀。
滑块 / 缺口 / 点选验证码
- 方案：DrissionPage / Playwright + YOLO (目标检测)
- 逻辑：截图 -> AI 识别缺口坐标 -> 生成模拟人类抖动的鼠标轨迹进行拖拽。
地狱级验证码 (ReCaptcha / hCaptcha)
- 方案：打码平台 (YesCaptcha / 2Captcha)
- 逻辑：不要自己破解。调用平台 API，支付少量费用获取 Token，这是工业界最稳方案。

💡 最终选型建议

初学者/简单任务 👉 Requests + BeautifulSoup
海量数据/通用爬取 👉 Scrapy
网站有 Cloudflare 盾 / 极其变态 👉 DrissionPage (强烈推荐)
需要处理滑块/复杂交互 👉 Playwright + YOLO
只被 TLS 指纹拦截 👉 curl_cffi

告别手动写爬虫代码-从F12到Python

手动编写 requests 代码经常因为标点符号、Header 格式错误、TLS 指纹识别或 Cookie 过期而导致报错，这是非常正常的情况。

针对**“把 cURL/F12 快速转成可运行代码”**这个需求，这里整理了四个“神器”帮你一键解决。按推荐程度排序如下：

CurlConverter (Web版/命令行)

定位： 最推荐，零门槛，全球开发者首选。

专门解决手动抄写 Header 和 Cookie 的痛点。它能把 cURL 命令完美“翻译”成 Python requests 代码（支持数十种语言）。

网址： curlconverter.com
优点： 自动处理 Header 格式、JSON 转义、Cookie 字典化，完全避免由于手误导致的 Bug。

使用步骤：

在浏览器 F12 开发者工具的网络面板中，右键点击请求 -> Copy as cURL。
打开网站，直接粘贴到左边的文本框里。
右边会自动生成 Python 代码，直接复制到 IDE 运行即可。

Postman (调试神器)

定位： 先验证请求有效性，再生成代码。

如果你生成的代码跑不通，很有可能是请求本身的问题（如 Cookie 已过期）。Postman 允许你在可视化界面先测通接口。

使用步骤：

打开 Postman，点击左上角的 Import -> Raw Text。
粘贴 cURL 命令并点击 Import，Postman 会自动填充参数。
点击 Send 测试：
- 如果报错，说明 Cookie 或参数失效，需重新抓包。
- 如果成功，点击右侧栏的 </> 图标 (Code snippet)。
选择 Python - Requests，复制生成的代码。

进阶大杀器：curl_cffi

定位： 解决“代码逻辑没错，但被服务器拦截 (403 Forbidden)”的问题。

重点注意： 如果 CurlConverter 生成的代码一模一样却报错（如 403 或连接重置），大概率是因为 TLS 指纹识别。百度、Cloudflare 等大厂会识别 Python requests 库的指纹并拦截。

解决方案： 使用 curl_cffi 库模拟真实浏览器指纹。

安装：

pip install curl_cffi

代码示例：

用法几乎与 requests 一致，只需增加 impersonate 参数：

from curl_cffi import requests

# 把生成的 requests 代码拿过来，改成用 curl_cffi 调用
response = requests.post(
 "YOUR_URL_HERE",
 headers=headers,
 data=data,
 impersonate="chrome110" # 关键：伪装成 Chrome 浏览器
)

4. 终极懒人方案：Playwright Codegen

定位： 录制即代码，解决极其复杂的反爬虫。

如果你不想分析接口参数，也不想处理反爬，可以直接使用浏览器自动化录制。虽然运行效率比 requests 低，但因其是真实浏览器操作，极难被屏蔽。

使用步骤：

在终端输入以下命令，浏览器会自动弹出：

playwright codegen fanyi.baidu.com

你在这个浏览器里的每一次点击和输入，终端窗口都会实时生成对应的 Python 代码。

总结与建议

第一步： 先用 CurlConverter 转换代码，尝试运行。
第二步： 如果代码报 403/404 或 Connection Error，说明遭遇反爬，请放弃标准 requests，直接改用 curl_cffi。
调试： 如果还是无法解决，请检查 HTTP 状态码或 Python 抛出的具体 Exception。


下一步建议
如果您在使用 `curl_cffi` 后仍然遇到报错，或者需要处理更复杂的动态加载页面（JavaScript 渲染），您希望我为您生成一段 **Playwright 的基础启动代码** 吗？

微信小程序使用教程——WechatMiniProgram

Sun, 08 Jun 2025 23:37:17 +0800

第一部分：微信小程序简介

微信小程序是一种无需下载安装即可使用的轻量级应用，通过微信平台运行。它具有开发简单、用户体验流畅、易于推广等特点，广泛应用于电商、工具、服务等领域。

特点：

无需安装：用户扫码或搜索即可使用。
跨平台：基于微信生态，无需适配多系统。
开发简单：使用类似 HTML、CSS、JavaScript 的技术栈。

第二部分：准备工作

在开始开发之前，你需要准备以下工具和环境：

1. 注册微信小程序账号

前往微信公众平台。
点击“立即注册”，选择“小程序”类型。
填写邮箱、密码等信息，完成注册。
注册后会获得一个 AppID（小程序唯一标识），后续开发需要用到。

2. 下载微信开发者工具

访问微信开发者工具下载页面。
根据你的操作系统（Windows、Mac 或 Linux）下载稳定版工具。
安装完成后，用注册时绑定的微信号扫码登录。

3. 技术基础

微信小程序使用以下技术：

WXML（类似 HTML）：用于结构。
WXSS（类似 CSS）：用于样式。
JavaScript：用于逻辑。
JSON：用于配置。

如果你熟悉前端开发，这些技术上手会很快。

第三部分：创建一个简单的小程序

我们将通过一个简单的 “Hello World” 示例，带你了解小程序的开发流程。

1. 创建项目

打开微信开发者工具。
点击“小程序” -> “新建项目”。
填写以下信息：
- 项目目录：选择一个空文件夹存放项目文件。
- AppID：输入你在公众平台注册时获得的 AppID（测试可用“测试号”）。
- 项目名称：例如 “HelloWorld”。
选择“小程序·原生开发”，点击“确定”。

2. 理解项目结构

创建后，项目目录如下：

├── pages // 页面文件夹
│ ├── index // 默认首页
│ │ ├── index.js // 页面逻辑
│ │ ├── index.json // 页面配置
│ │ ├── index.wxml // 页面结构
│ │ └── index.wxss // 页面样式
├── app.js // 小程序全局逻辑
├── app.json // 小程序全局配置
├── app.wxss // 小程序全局样式
└── project.config.json // 项目配置文件

3. 编辑首页

我们将修改 pages/index 下的文件，显示一个简单的 “Hello World” 文本。

index.wxml（页面结构）：

<view class="container">
 <text>Hello World</text>
</view>

index.wxss（页面样式）：

.container {
 display: flex;
 justify-content: center;
 align-items: center;
 height: 100vh;
 font-size: 36rpx;
 color: #333;
}

index.js（页面逻辑，暂时无需修改）：

Page({
 data: {
 // 数据可以在此定义
 }
})

index.json（页面配置，可选）：

{
 "navigationBarTitleText": "首页"
}

4. 配置全局文件

app.json（全局配置）：

{
 "pages": [
 "pages/index/index" // 默认首页路径
 ],
 "window": {
 "backgroundTextStyle": "light",
 "navigationBarBackgroundColor": "#fff",
 "navigationBarTitleText": "我的小程序",
 "navigationBarTextStyle": "black"
 }
}

5. 预览效果

在微信开发者工具顶部，点击“预览”。
用手机微信扫码，即可在手机上看到 “Hello World” 显示在屏幕中央。

第四部分：添加交互功能

我们为小程序添加一个按钮，点击后显示一条消息。

1. 修改 WXML

编辑 pages/index/index.wxml：

<view class="container">
 <text>{{msg}}</text>
 <button bindtap="showMessage">点击我</button>
</view>

2. 修改 JS

编辑 pages/index/index.js：

Page({
 data: {
 msg: "Hello World" // 初始文本
 },
 showMessage: function() {
 this.setData({
 msg: "你点击了按钮！"
 });
 }
});

3. 修改 WXSS

编辑 pages/index/index.wxss，美化按钮：

.container {
 display: flex;
 flex-direction: column;
 justify-content: center;
 align-items: center;
 height: 100vh;
 font-size: 36rpx;
 color: #333;
}

button {
 margin-top: 20rpx;
 background-color: #07c160;
 color: #fff;
}

4. 测试

点击“预览”，扫码后在手机上点击按钮，文本会从 “Hello World” 变为 “你点击了按钮！”。

第五部分：发布小程序

开发完成后，你可以将其发布到微信平台供用户使用。

上传代码：
- 在开发者工具中，点击右上角“上传”。
- 填写版本号（如 “1.0.0”）和备注，上传成功后可在公众平台看到。
提交审核：
- 登录微信公众平台。
- 在“小程序管理” -> “版本管理”中，找到上传的版本，点击“提交审核”。
- 填写相关信息（如小程序类目、功能介绍），等待微信团队审核（通常 1-7 天）。
发布上线：
- 审核通过后，点击“发布”，小程序即可上线，用户可通过搜索或扫码使用。

第六部分：学习资源与进阶

官方资源：

进阶建议：

学习 云开发：微信提供云函数、数据库、存储等功能。
掌握 自定义组件：提高代码复用性。
探索 小程序插件：扩展功能。

野火F103-MiNI使用教程

Thu, 15 May 2025 13:49:09 +0800

问答：

什么是GPIO ？

General-purpose input/output通用型之输入输出的简称

IRQ

IRQ (Interrupt ReQuest) 指来自设备的中断请求。

RCC的功能

RCC (Reset and Clock Control) 是嵌入式系统中负责管理系统时钟和复位功能的重要模块。让我详细解释一下：

RCC的主要功能：

系统时钟配置和管理
外设时钟的使能和失能
时钟源的选择（内部/外部时钟）
时钟频率的分频和倍频
系统复位控制

主要时钟源类型：

HSI (High Speed Internal) - 内部高速时钟
HSE (High Speed External) - 外部高速时钟
LSI (Low Speed Internal) - 内部低速时钟
LSE (Low Speed External) - 外部低速时钟
PLL (Phase-Locked Loop) - 锁相环

RCC在实际开发中的应用：

// 以STM32为例，开启GPIOA时钟的代码
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

// 配置系统时钟的示例
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

 // 配置振荡器
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
 RCC_OscInitStruct.HSEState = RCC_HSE_ON;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 // ... 其他配置

 HAL_RCC_OscConfig(&RCC_OscInitStruct);

 // 配置时钟树
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 // ... 其他配置

 HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2);
}

RCC配置的重要性：

影响系统性能和功耗
决定外设工作频率
确保系统稳定运行
为低功耗模式切换提供支持

使用RCC时的注意事项：

配置时序要按照数据手册要求
注意时钟树的依赖关系
考虑系统供电和功耗需求
确保外设时钟频率在允许范围内
正确处理时钟切换过程中的稳定等待

理解和正确使用RCC对于嵌入式系统的开发至关重要，它直接影响着系统的性能、稳定性和功耗。不同的芯片厂商可能对RCC的具体实现有所不同，但基本概念和功能是类似的。

STM的固件库在哪里下载

https://bbs.21ic.com/icview-3349496-1-1.html

Step1. 安装keli

方法，直接在网上搜索就可以，也可以看网易课堂提到的网盘链接 https://study.163.com/course/courseLearn.htm?courseId=1006447055#/learn/video?lessonId=1054086739&courseId=1006447055

Step2. 安装芯片组

https://www.keil.arm.com/devices/ 可以到keil的官网进行下载，我下载的是然后找到 F103 对应的芯片组软件

Step3. 使用DAP仿真器下载程序

像这样连接线材，连接DAP的USB-A口插到电脑上，另一个连到板子上的接电源。

使用keil打开测试固件的程序

下载程序到开发板，一会进度条加载完就下载好了

点击下图的第二个按钮就可以切换灯了

7-（第一节）新建工程模板-寄存器版

新建项目-并选择芯片
导入启动文件 XX.s
创建main.c文件
创建stm32f10x.h 固件库

5.连接DAP设置

图1	图2
图3	图4
图5	图6

7-（第二节）使用寄存器点亮LED

本节课代码如下，为什么和老师代码不一样？因为我觉得老师教错了，在CRL这里

#include "stm32f10x.h"
int main(void)
{
 // RCC
 *(unsigned int *)0X40021018 |= (1<<4);

 //ODR
 *(unsigned int *)0X4001100C &= ~(1<<2);

 //CRL
 *(unsigned int *)0X40011000 |= (1<<8);
 *(unsigned int *)0X40011000 &= ~(1<<10); //这里我和老师不一样，不过效果是一样的，后续代码我就按照老师的来了
}

int SystemInit(void)
{
}

找到寄存器的地址（寄存器的GPIO的起始地址 + 偏移地址），因为是MINI开发板子上的端口PC2对应的是C，所以找CPIOC
配置ODR寄存器，其中可以用ODR中的第四位控制灯泡，具体咱回事我没太弄懂
CRL寄存器，这个是控制输入还是输出，以及用什么模式的，设置为“推挽输出”，又因为第一步对应PC2，对应的是‘2’
打开时钟CRC寄存器（APB2外设时钟使能寄存器：为什么是APB2，因为GPIO在APB2总线上），如果要读取外设就必须要打开。
(unsigned int *)0X4001100C是什么意思？

这是将内存地址 0X4001100C 转换为指向 unsigned int 类型的指针。指针类型是为了：

告诉编译器如何解释内存中的数据。比如 unsigned int* 指针解引用时，会把那个地址的4个字节当作无符号整数来读取

指针运算时确定步长。unsigned int* 加1会前进4个字节，而 char* 加1只前进1个字节

为什么指针也有类型？

指针类型是为了：

告诉编译器如何解释内存中的数据。比如 unsigned int* 指针解引用时，会把那个地址的4个字节当作无符号整数来读取指针运算时确定步长。unsigned int* 加1会前进4个字节，而 char* 加1只前进1个字节一般我们这样定义

unsigned int* p1 = (unsigned int*)0x1000;
p1 + 1; // 0x1004
char* p2 = (char*)0x1000;
p2 + 1; // 0x1001

*(unsigned int *)0X4001100C什么意思?

*(unsigned int *)0X4001100C 对内存地址 0X4001100C 进行解引用(*),获取该地址存储的无符号整数值。

举例:

// 读取该地址的值
unsigned int value = *(unsigned int *)0X4001100C;

// 写入值到该地址
*(unsigned int *)0X4001100C = 0x1;

这种操作常用于直接读写硬件寄存器。

为什么要这么麻烦，直接*0X4001100C行不行

不行,因为 0X4001100C 是一个数值常量,直接用*解引用会出错。需要先把它转换成指针类型((unsigned int *)),才能进行解引用操作。

这是C语言的语法规则要求 - 解引用操作必须作用于指针类型。

*(unsigned int *)0X4001100C &= ~(1«2) 的含义：

0X4001100C 是内存地址，要加(unsigned int *)转成指针才能解引用 1«2 产生二进制…0100 ~ 取反得到…1011 &= 进行AND操作，会把对应地址值的第2位清零，因为0和任何值做AND都得0 其他位保持不变，因为1和原值做AND保持原值

&= ~ 和 |= 的作用

正如第五问所问： &= ~ 用来清零 |= 用来写1 当然操作过程要用到位运算（1<<XXX）

这节课的视频里面，老师为什么说4位为一组？

STM32寄存器中4位一组是因为：

每4位可以表示一个16进制数(0-F)

容易读写和分组管理

符合很多外设配置的需求（如GPIO的4位可以配置一个引脚的模式）

例如一个32位寄存器可以分为8组，每组4位，方便配置和管理不同功能。那么很显然，如果你在C语言里面用2进制表示的话，实际上也是可以的，不过就是麻烦点

8-使用寄存器点亮LED

第8课包含两节：第一节说功能框图（具体内容可以看STM32F10X-中文参考这本电子书）第二节把第7课中的地址通过定义一个常量做映射

没有什么太有争议或者难以理解的内容

9-1自己写库（第一节）-GPIO寄存器结构体定义

代码如下

//stm32f10x.h
#define PERIPH_BASE ((unsigned int)0x40000000)
#define APB1PERIPH_BASE PERIPH_BASE
#define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
#define AHBPERIPH_BASE (PERIPH_BASE + 0x20000)


#define RCC_BASE (AHBPERIPH_BASE + 0x1000)
#define GPIOC_BASE (APB2PERIPH_BASE + 0x1000)


#define RCC_APB2ENR *(unsigned int*)(RCC_BASE + 0x18)


typedef unsigned int uint32_t;
typedef unsigned short uint16_t;

typedef struct
{
 uint32_t CRL;
 uint32_t CRH;
 uint32_t IDR;
 uint32_t ODR;
 uint32_t BSRR;
 uint32_t BRR;
 uint32_t LCKR;
}GPIO_TypeDef;


#define GPIOC ((GPIO_TypeDef*)GPIOC_BASE)

这是定义了一个名为GPIO_TypeDef的结构体，用于映射GPIO外设的寄存器布局：

```c
typedef struct {
uint32_t CRL; // 端口配置低寄存器 (0x00)
uint32_t CRH; // 端口配置高寄存器 (0x04)
uint32_t IDR; // 端口输入数据寄存器 (0x08)
uint32_t ODR; // 端口输出数据寄存器 (0x0C)
uint32_t BSRR; // 端口位设置/清除寄存器 (0x10)
uint32_t BRR; // 端口位清除寄存器 (0x14)
uint32_t LCKR; // 端口配置锁定寄存器 (0x18)
} GPIO_TypeDef;
```

结构体成员的排列顺序与寄存器在内存中的实际布局一致。这样通过结构体指针就可以直接访问这些寄存器

这基于C语言结构体在内存中的存储原理：

连续性：结构体成员在内存中按声明顺序连续存储
对齐：每个成员按其类型的对齐要求存储。这里uint32_t通常4字节对齐，刚好对应寄存器间隔：
```
CRL - 0x00
CRH - 0x04
IDR - 0x08
ODR - 0x0C
```
指针访问：当把GPIOC_BASE转为GPIO_TypeDef指针时，编译器会根据结构体布局自动计算每个成员的偏移量，从而访问到对应寄存器

这样就实现了通过结构体直接操作物理寄存器。
```
GPIO_TypeDef* GPIOC = (GPIO_TypeDef*)GPIOC_BASE;
GPIOC->ODR = ...; // 访问ODR寄存器
```

//main,c
#include "stm32f10x.h"

int main (void)
{

 // 打开时钟
 RCC_APB2ENR |= ( (1) << 4 );

 // 配置IO口为输出
 GPIOC->CRL |= ( (1) << (4*2) );

 // 控制ODR寄存器
 GPIOC->ODR &= ~(1<<2);
 //GPIOC->ODR |= (1<<2);
}


void SystemInit(void)
{
 //函数体为空为了骗过编译器
}

9-2编写GPIO端口置位复位函数

先贴代码:

main.c

#include "stm32f10x.h"
#include "stm32f10x_gpio.h"

void soft_delay( unsigned int count)
{
 for(;count !=0 ;count--);
}

int main (void)
{
 // 打开 GPIOC 端口的时钟
 RCC->APB2ENR |= ( (1) << 4 );

 // 配置IO口为输出
 //GPIOC->CRL &= ~( (10000) << (4*2) );
 GPIOC->CRL |= ( (1) << (4*2) );

 // 配置ODR寄存器
 //GPIOC->ODR &= ~(1<<2);
 GPIO_SetBits(GPIOC,(1<<2));
 while(1)
 {
 //GPIOC->ODR |= (1<<2);
 GPIO_ResetBits(GPIOC,(1<<2));
 soft_delay(1000000); // 这里用10进制表示的

 //GPIOC->ODR &= ~(1<<2);
 GPIO_SetBits(GPIOC,(1<<2));
 soft_delay(1000000);
 }
}
void SystemInit(void)
{
 // 函数体为空，目的是为了骗过编译器不报错
}

stm32f10x.h

#ifndef __STM32F10X_H
#define __STM32F10X_H

#define PERIPH_BASE ((unsigned int)0x40000000)
#define APB1PERIPH_BASE PERIPH_BASE
#define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
#define AHBPERIPH_BASE (PERIPH_BASE + 0x20000)

#define RCC_BASE (AHBPERIPH_BASE + 0x1000)
#define GPIOC_BASE (APB2PERIPH_BASE + 0x1000)

#define RCC_APB2ENR *(unsigned int*)(RCC_BASE + 0x18)

typedef unsigned int uint32_t;
typedef unsigned short uint16_t;

typedef struct
{
 uint32_t CRL;
 uint32_t CRH;
 uint32_t IDR;
 uint32_t ODR;
 uint32_t BSRR;
 uint32_t BRR;
 uint32_t LCKR;
}GPIO_TypeDef;

typedef struct
{
 uint32_t CR;
 uint32_t CFGR;
 uint32_t CIR;
 uint32_t APB2RSTR;
 uint32_t APB1RSTR;
 uint32_t AHBENR;
 uint32_t APB2ENR;
 uint32_t APB1ENR;
 uint32_t BDCR;
 uint32_t CSR;
}RCC_TypeDef;

#define GPIOC ((GPIO_TypeDef*)GPIOC_BASE)
#define RCC ((RCC_TypeDef*)RCC_BASE)

#endif /* __STM32F10X_H */

stm32f10x_gpio.h

#ifndef __STM32F10X_GPIO_H
#define __STM32F10X_GPIO_H

#include "stm32f10x.h"

void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
void GPIO_ResetBits( GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin );

#endif /* __STM32F10X_GPIO_H */

stm32f10x_gpio.c

#include "stm32f10x_gpio.h"

/**
* 函数功能：设置引脚为高电平
* 参数说明：GPIOx: 该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
* GPIO_Pin: 选择要设置的 GPIO 端口引脚，可输入宏 GPIO_Pin_0-15，
* 表示 GPIOx 端口的 0-15 号引脚。
*/
void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
{

 /* 设置 GPIOx 端口 BSRR 寄存器的第 GPIO_Pin 位，使其输出高电平 */
 /* 因为 BSRR 寄存器写 0 不影响，宏 GPIO_Pin 只是对应位为 1，其它位均为 0，所以可以直接赋值 */

 GPIOx->BSRR |= GPIO_Pin;
}

/**
* 函数功能：设置引脚为低电平
* 参数说明：GPIOx: 该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
* GPIO_Pin: 选择要设置的 GPIO 端口引脚，可输入宏 GPIO_Pin_0-15，
* 表示 GPIOx 端口的 0-15 号引脚。
*/
void GPIO_ResetBits( GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin )
{

 /* 设置 GPIOx 端口 BRR 寄存器的第 GPIO_Pin 位, 使其输出低电平 */
 /* 因为 BRR 寄存器写 0 不影响，宏 GPIO_Pin 只是对应位为 1，其它位均为 0，所以可以直接赋值 */

 GPIOx->BRR |= GPIO_Pin;
}

1. 为什么没有引入stm32f10x_gpio.c，也能正常调用其中的函数

这个问题涉及到C语言编译和链接的概念。让我来详细解释：
在这个项目中，虽然代码中没有直接 #include "stm32f10x_gpio.c"，但程序仍然能够正常工作，原因是：

main.c 引入了 stm32f10x_gpio.h 头文件，该头文件声明了 GPIO_SetBits 和 GPIO_ResetBits 这两个函数

stm32f10x_gpio.c 源文件包含了这两个函数的实际实现

在项目编译时，编译器会分别编译 main.c 和 stm32f10x_gpio.c，然后链接器会将它们链接在一起

实际上，直接引入 .c 文件通常是不推荐的做法：

头文件(.h)用于声明函数接口

源文件(.c)用于实现具体功能

编译器会分别编译各个源文件，然后链接器将它们组合成最终的可执行文件
编译过程是这样的：
 main.c ────┐
├── 编译 --> 链接 --> 可执行文件
stm32f10x_gpio.c ─┘
如果你直接 #include "stm32f10x_gpio.c"，可能会导致：

函数重复定义错误（如果该.c文件在多个地方被引入）

编译时间增加

代码组织混乱
所以正确的做法就是你现在的方式：

在头文件中声明函数

在源文件中实现函数

在项目配置中将所有需要的源文件加入编译

这样可以保持代码的模块化和可维护性，同时避免潜在的编译错误。

2. 头文件防重

代码
 #ifndef __STM32F10X_GPIO_H
#define __STM32F10X_GPIO_H // 头文件内容
#endif
这种方式称为"Include Guard"或"Header Guard" 防止头文件被重复包含导致的重复定义问题有些编译器也支持 #pragma once，效果类似

3. 声明和定义的区别

// 声明 - 告诉编译器函数的存在 void func(int x);
// 定义 - 提供函数的具体实现 void func(int x) {}

4. 条件编译：

#ifdef DEBUG
 // 调试代码
#else
 // 发布代码
#endif

#if defined(PLATFORM_A)
 // 平台A的代码
#elif defined(PLATFORM_B)
 // 平台B的代码
#endif

9-3 自己写库，构建库函数雏形

代码如下 以下是文件夹的结构和内容：

目录结构： 📄 main.c 📄 startup_stm32f10x_hd.s // 启动文件 📄 stm32f10x.h 📄 stm32f10x_gpio.c 📄 stm32f10x_gpio.h

文件 ‘main.c’：

#include "stm32f10x.h"
#include "stm32f10x_gpio.h"

#define LED_G_GPIO_PORT GPIOC
#define LED_G_GPIO_CLK_ENABLE (RCC->APB2ENR |= ( (1) << 4 ))
#define LED_G_GPIO_PIN GPIO_Pin_2

void Delay(uint32_t count)
{
 for( ; count !=0; count-- );
}

int main (void)
{
 GPIO_InitTypeDef GPIO_InitStructure;

 // 打开 GPIOC 端口的时钟
 LED_G_GPIO_CLK_ENABLE;

 GPIO_InitStructure.GPIO_Pin = LED_G_GPIO_PIN;
 GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
 GPIO_Init(LED_G_GPIO_PORT, &GPIO_InitStructure);

 while(1)
 {
 GPIO_SetBits(LED_G_GPIO_PORT,LED_G_GPIO_PIN);
 Delay(0xFFFF);
 GPIO_ResetBits(LED_G_GPIO_PORT,LED_G_GPIO_PIN);
 Delay(0xFFFF);
 }

}

void SystemInit(void)
{
 // 函数体为空，目的是为了骗过编译器不报错
}

文件 ‘stm32f10x.h’：

#ifndef __STM32F10X_H
#define __STM32F10X_H

// 用来存放STM32寄存器映射的代码

// 外设 perirhral

#define PERIPH_BASE ((unsigned int)0x40000000)
#define APB1PERIPH_BASE PERIPH_BASE
#define APB2PERIPH_BASE (PERIPH_BASE + 0x10000)
#define AHBPERIPH_BASE (PERIPH_BASE + 0x20000)


#define RCC_BASE (AHBPERIPH_BASE + 0x1000)
#define GPIOC_BASE (APB2PERIPH_BASE + 0x1000)


#define RCC_APB2ENR *(unsigned int*)(RCC_BASE + 0x18)

#define GPIOC_CRL *(unsigned int*)(GPIOC_BASE + 0x00)
#define GPIOC_CRH *(unsigned int*)(GPIOC_BASE + 0x04)
#define GPIOC_IDR *(unsigned int*)(GPIOC_BASE + 0x08)
#define GPIOC_ODR *(unsigned int*)(GPIOC_BASE + 0x0C)
#define GPIOC_BSRR *(unsigned int*)(GPIOC_BASE + 0x10)
#define GPIOC_BRR *(unsigned int*)(GPIOC_BASE + 0x14)
#define GPIOC_LCKR *(unsigned int*)(GPIOC_BASE + 0x18)

typedef unsigned int uint32_t;
typedef unsigned short uint16_t;

typedef struct
{
 uint32_t CRL;
 uint32_t CRH;
 uint32_t IDR;
 uint32_t ODR;
 uint32_t BSRR;
 uint32_t BRR;
 uint32_t LCKR;
}GPIO_TypeDef;


typedef struct
{
 uint32_t CR;
 uint32_t CFGR;
 uint32_t CIR;
 uint32_t APB2RSTR;
 uint32_t APB1RSTR;
 uint32_t AHBENR;
 uint32_t APB2ENR;
 uint32_t APB1ENR;
 uint32_t BDCR;
 uint32_t CSR;
}RCC_TypeDef;


#define GPIOC ((GPIO_TypeDef*)GPIOC_BASE)
#define RCC ((RCC_TypeDef*)RCC_BASE)

#endif /* __STM32F10X_H */

文件 ‘stm32f10x_gpio.c’：

#include "stm32f10x_gpio.h"

/**
* 函数功能：设置引脚为高电平
* 参数说明：GPIOx: 该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
* GPIO_Pin: 选择要设置的 GPIO 端口引脚，可输入宏 GPIO_Pin_0-15，
* 表示 GPIOx 端口的 0-15 号引脚。
*/
void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin)
{

 /* 设置 GPIOx 端口 BSRR 寄存器的第 GPIO_Pin 位，使其输出高电平 */
 /* 因为 BSRR 寄存器写 0 不影响，宏 GPIO_Pin 只是对应位为 1，其它位均为 0，所以可以直接赋值 */

 GPIOx->BSRR |= GPIO_Pin;
}



/**
* 函数功能：设置引脚为低电平
* 参数说明：GPIOx: 该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
* GPIO_Pin: 选择要设置的 GPIO 端口引脚，可输入宏 GPIO_Pin_0-15，
* 表示 GPIOx 端口的 0-15 号引脚。
*/
void GPIO_ResetBits( GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin )
{

 /* 设置 GPIOx 端口 BRR 寄存器的第 GPIO_Pin 位, 使其输出低电平 */
 /* 因为 BRR 寄存器写 0 不影响，宏 GPIO_Pin 只是对应位为 1，其它位均为 0，所以可以直接赋值 */

 GPIOx->BRR |= GPIO_Pin;
}


/**
* 函数功能：初始化引脚模式
* 参数说明：GPIOx，该参数为 GPIO_TypeDef 类型的指针，指向 GPIO 端口的地址
* GPIO_InitTypeDef:GPIO_InitTypeDef 结构体指针，指向初始化变量
*/
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
{
 uint32_t currentmode = 0x00, currentpin = 0x00, pinpos = 0x00, pos = 0x00;
 uint32_t tmpreg = 0x00, pinmask = 0x00;

/*---------------------- GPIO 模式配置 --------------------------*/
 // 把输入参数GPIO_Mode的低四位暂存在currentmode
 currentmode = ((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x0F);

 // bit4是1表示输出，bit4是0则是输入
 // 判断bit4是1还是0，即首选判断是输入还是输出模式
 if ((((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x10)) != 0x00)
 {
 // 输出模式则要设置输出速度
 currentmode |= (uint32_t)GPIO_InitStruct->GPIO_Speed;
 }
/*-------------GPIO CRL 寄存器配置 CRL寄存器控制着低8位IO- -------*/
 // 配置端口低8位，即Pin0~Pin7
 if (((uint32_t)GPIO_InitStruct->GPIO_Pin & ((uint32_t)0x00FF)) != 0x00)
 {
 // 先备份CRL寄存器的值
 tmpreg = GPIOx->CRL;

 // 循环，从Pin0开始配对，找出具体的Pin
 for (pinpos = 0x00; pinpos < 0x08; pinpos++)
 {
 // pos的值为1左移pinpos位
 pos = ((uint32_t)0x01) << pinpos;

 // 令pos与输入参数GPIO_PIN作位与运算，为下面的判断作准备
 currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;

 //若currentpin=pos,则找到使用的引脚
 if (currentpin == pos)
 {
 // pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
 pos = pinpos << 2;
 //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
 pinmask = ((uint32_t)0x0F) << pos;
 tmpreg &= ~pinmask;

 // 向寄存器写入将要配置的引脚的模式
 tmpreg |= (currentmode << pos);

 // 判断是否为下拉输入模式
 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
 {
 // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
 GPIOx->BRR = (((uint32_t)0x01) << pinpos);
 }
 else
 {
 // 判断是否为上拉输入模式
 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
 {
 // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
 GPIOx->BSRR = (((uint32_t)0x01) << pinpos);
 }
 }
 }
 }
 // 把前面处理后的暂存值写入到CRL寄存器之中
 GPIOx->CRL = tmpreg;
 }
/*-------------GPIO CRH 寄存器配置 CRH寄存器控制着高8位IO- -----------*/
 // 配置端口高8位，即Pin8~Pin15
 if (GPIO_InitStruct->GPIO_Pin > 0x00FF)
 {
 // // 先备份CRH寄存器的值
 tmpreg = GPIOx->CRH;

 // 循环，从Pin8开始配对，找出具体的Pin
 for (pinpos = 0x00; pinpos < 0x08; pinpos++)
 {
 pos = (((uint32_t)0x01) << (pinpos + 0x08));

 // pos与输入参数GPIO_PIN作位与运算
 currentpin = ((GPIO_InitStruct->GPIO_Pin) & pos);

 //若currentpin=pos,则找到使用的引脚
 if (currentpin == pos)
 {
 //pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
 pos = pinpos << 2;

 //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
 pinmask = ((uint32_t)0x0F) << pos;
 tmpreg &= ~pinmask;

 // 向寄存器写入将要配置的引脚的模式
 tmpreg |= (currentmode << pos);

 // 判断是否为下拉输入模式
 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
 {
 // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
 GPIOx->BRR = (((uint32_t)0x01) << (pinpos + 0x08));
 }
 // 判断是否为上拉输入模式
 if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
 {
 // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
 GPIOx->BSRR = (((uint32_t)0x01) << (pinpos + 0x08));
 }
 }
 }
 // 把前面处理后的暂存值写入到CRH寄存器之中
 GPIOx->CRH = tmpreg;
 }
}

文件 ‘stm32f10x_gpio.h’：

#ifndef __STM32F10X_GPIO_H
#define __STM32F10X_GPIO_H

#include "stm32f10x.h"

#define GPIO_Pin_0 ((uint16_t)0x0001) /*!< 选择Pin0 */ //(00000000 00000001)b
#define GPIO_Pin_1 ((uint16_t)0x0002) /*!< 选择Pin1 */ //(00000000 00000010)b
#define GPIO_Pin_2 ((uint16_t)0x0004) /*!< 选择Pin2 */ //(00000000 00000100)b
#define GPIO_Pin_3 ((uint16_t)0x0008) /*!< 选择Pin3 */ //(00000000 00001000)b
#define GPIO_Pin_4 ((uint16_t)0x0010) /*!< 选择Pin4 */ //(00000000 00010000)b
#define GPIO_Pin_5 ((uint16_t)0x0020) /*!< 选择Pin5 */ //(00000000 00100000)b
#define GPIO_Pin_6 ((uint16_t)0x0040) /*!< 选择Pin6 */ //(00000000 01000000)b
#define GPIO_Pin_7 ((uint16_t)0x0080) /*!< 选择Pin7 */ //(00000000 10000000)b

#define GPIO_Pin_8 ((uint16_t)0x0100) /*!< 选择Pin8 */ //(00000001 00000000)b
#define GPIO_Pin_9 ((uint16_t)0x0200) /*!< 选择Pin9 */ //(00000010 00000000)b
#define GPIO_Pin_10 ((uint16_t)0x0400) /*!< 选择Pin10 */ //(00000100 00000000)b
#define GPIO_Pin_11 ((uint16_t)0x0800) /*!< 选择Pin11 */ //(00001000 00000000)b
#define GPIO_Pin_12 ((uint16_t)0x1000) /*!< 选择Pin12 */ //(00010000 00000000)b
#define GPIO_Pin_13 ((uint16_t)0x2000) /*!< 选择Pin13 */ //(00100000 00000000)b
#define GPIO_Pin_14 ((uint16_t)0x4000) /*!< 选择Pin14 */ //(01000000 00000000)b
#define GPIO_Pin_15 ((uint16_t)0x8000) /*!< 选择Pin15 */ //(10000000 00000000)b
#define GPIO_Pin_All ((uint16_t)0xFFFF) /*!< 选择全部引脚*/ //(11111111 11111111)b


typedef enum
{
 GPIO_Speed_10MHz = 1, // 10MHZ (01)b
 GPIO_Speed_2MHz, // 2MHZ (10)b
 GPIO_Speed_50MHz // 50MHZ (11)b
}GPIOSpeed_TypeDef;

typedef enum
{ GPIO_Mode_AIN = 0x0, // 模拟输入 (0000 0000)b
 GPIO_Mode_IN_FLOATING = 0x04, // 浮空输入 (0000 0100)b
 GPIO_Mode_IPD = 0x28, // 下拉输入 (0010 1000)b
 GPIO_Mode_IPU = 0x48, // 上拉输入 (0100 1000)b

 GPIO_Mode_Out_OD = 0x14, // 开漏输出 (0001 0100)b
 GPIO_Mode_Out_PP = 0x10, // 推挽输出 (0001 0000)b
 GPIO_Mode_AF_OD = 0x1C, // 复用开漏输出 (0001 1100)b
 GPIO_Mode_AF_PP = 0x18 // 复用推挽输出 (0001 1000)b
}GPIOMode_TypeDef;

typedef struct
{
 uint16_t GPIO_Pin;
 uint16_t GPIO_Speed;
 uint16_t GPIO_Mode;
}GPIO_InitTypeDef;

void GPIO_SetBits(GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin);
void GPIO_ResetBits( GPIO_TypeDef *GPIOx,uint16_t GPIO_Pin );
void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);

#endif /* __STM32F10X_GPIO_H */

文件 ‘startup_stm32f10x_hd.s’：

;******************** (C) COPYRIGHT 2011 STMicroelectronics ********************
;* File Name : startup_stm32f10x_hd.s
;* Author : MCD Application Team
;* Version : V3.5.0
;* Date : 11-March-2011
;* Description : STM32F10x High Density Devices vector table for MDK-ARM
;* toolchain.
;* This module performs:
;* - Set the initial SP
;* - Set the initial PC == Reset_Handler
;* - Set the vector table entries with the exceptions ISR address
;* - Configure the clock system and also configure the external
;* SRAM mounted on STM3210E-EVAL board to be used as data
;* memory (optional, to be enabled by user)
;* - Branches to __main in the C library (which eventually
;* calls main()).
;* After Reset the CortexM3 processor is in Thread mode,
;* priority is Privileged, and the Stack is set to Main.
;* <<< Use Configuration Wizard in Context Menu >>>
;*******************************************************************************
; THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
; WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME.
; AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
; INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE
; CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING
; INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
;*******************************************************************************

; Amount of memory (in bytes) allocated for Stack
; Tailor this value to your application needs
; <h> Stack Configuration
; <o> Stack Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Stack_Size EQU 0x00000400

 AREA STACK, NOINIT, READWRITE, ALIGN=3
Stack_Mem SPACE Stack_Size
__initial_sp

; <h> Heap Configuration
; <o> Heap Size (in Bytes) <0x0-0xFFFFFFFF:8>
; </h>

Heap_Size EQU 0x00000200

 AREA HEAP, NOINIT, READWRITE, ALIGN=3
__heap_base
Heap_Mem SPACE Heap_Size
__heap_limit

 PRESERVE8
 THUMB


; Vector Table Mapped to Address 0 at Reset
 AREA RESET, DATA, READONLY
 EXPORT __Vectors
 EXPORT __Vectors_End
 EXPORT __Vectors_Size

__Vectors DCD __initial_sp ; Top of Stack
 DCD Reset_Handler ; Reset Handler
 DCD NMI_Handler ; NMI Handler
 DCD HardFault_Handler ; Hard Fault Handler
 DCD MemManage_Handler ; MPU Fault Handler
 DCD BusFault_Handler ; Bus Fault Handler
 DCD UsageFault_Handler ; Usage Fault Handler
 DCD 0 ; Reserved
 DCD 0 ; Reserved
 DCD 0 ; Reserved
 DCD 0 ; Reserved
 DCD SVC_Handler ; SVCall Handler
 DCD DebugMon_Handler ; Debug Monitor Handler
 DCD 0 ; Reserved
 DCD PendSV_Handler ; PendSV Handler
 DCD SysTick_Handler ; SysTick Handler

 ; External Interrupts
 DCD WWDG_IRQHandler ; Window Watchdog
 DCD PVD_IRQHandler ; PVD through EXTI Line detect
 DCD TAMPER_IRQHandler ; Tamper
 DCD RTC_IRQHandler ; RTC
 DCD FLASH_IRQHandler ; Flash
 DCD RCC_IRQHandler ; RCC
 DCD EXTI0_IRQHandler ; EXTI Line 0
 DCD EXTI1_IRQHandler ; EXTI Line 1
 DCD EXTI2_IRQHandler ; EXTI Line 2
 DCD EXTI3_IRQHandler ; EXTI Line 3
 DCD EXTI4_IRQHandler ; EXTI Line 4
 DCD DMA1_Channel1_IRQHandler ; DMA1 Channel 1
 DCD DMA1_Channel2_IRQHandler ; DMA1 Channel 2
 DCD DMA1_Channel3_IRQHandler ; DMA1 Channel 3
 DCD DMA1_Channel4_IRQHandler ; DMA1 Channel 4
 DCD DMA1_Channel5_IRQHandler ; DMA1 Channel 5
 DCD DMA1_Channel6_IRQHandler ; DMA1 Channel 6
 DCD DMA1_Channel7_IRQHandler ; DMA1 Channel 7
 DCD ADC1_2_IRQHandler ; ADC1 & ADC2
 DCD USB_HP_CAN1_TX_IRQHandler ; USB High Priority or CAN1 TX
 DCD USB_LP_CAN1_RX0_IRQHandler ; USB Low Priority or CAN1 RX0
 DCD CAN1_RX1_IRQHandler ; CAN1 RX1
 DCD CAN1_SCE_IRQHandler ; CAN1 SCE
 DCD EXTI9_5_IRQHandler ; EXTI Line 9..5
 DCD TIM1_BRK_IRQHandler ; TIM1 Break
 DCD TIM1_UP_IRQHandler ; TIM1 Update
 DCD TIM1_TRG_COM_IRQHandler ; TIM1 Trigger and Commutation
 DCD TIM1_CC_IRQHandler ; TIM1 Capture Compare
 DCD TIM2_IRQHandler ; TIM2
 DCD TIM3_IRQHandler ; TIM3
 DCD TIM4_IRQHandler ; TIM4
 DCD I2C1_EV_IRQHandler ; I2C1 Event
 DCD I2C1_ER_IRQHandler ; I2C1 Error
 DCD I2C2_EV_IRQHandler ; I2C2 Event
 DCD I2C2_ER_IRQHandler ; I2C2 Error
 DCD SPI1_IRQHandler ; SPI1
 DCD SPI2_IRQHandler ; SPI2
 DCD USART1_IRQHandler ; USART1
 DCD USART2_IRQHandler ; USART2
 DCD USART3_IRQHandler ; USART3
 DCD EXTI15_10_IRQHandler ; EXTI Line 15..10
 DCD RTCAlarm_IRQHandler ; RTC Alarm through EXTI Line
 DCD USBWakeUp_IRQHandler ; USB Wakeup from suspend
 DCD TIM8_BRK_IRQHandler ; TIM8 Break
 DCD TIM8_UP_IRQHandler ; TIM8 Update
 DCD TIM8_TRG_COM_IRQHandler ; TIM8 Trigger and Commutation
 DCD TIM8_CC_IRQHandler ; TIM8 Capture Compare
 DCD ADC3_IRQHandler ; ADC3
 DCD FSMC_IRQHandler ; FSMC
 DCD SDIO_IRQHandler ; SDIO
 DCD TIM5_IRQHandler ; TIM5
 DCD SPI3_IRQHandler ; SPI3
 DCD UART4_IRQHandler ; UART4
 DCD UART5_IRQHandler ; UART5
 DCD TIM6_IRQHandler ; TIM6
 DCD TIM7_IRQHandler ; TIM7
 DCD DMA2_Channel1_IRQHandler ; DMA2 Channel1
 DCD DMA2_Channel2_IRQHandler ; DMA2 Channel2
 DCD DMA2_Channel3_IRQHandler ; DMA2 Channel3
 DCD DMA2_Channel4_5_IRQHandler ; DMA2 Channel4 & Channel5
__Vectors_End

__Vectors_Size EQU __Vectors_End - __Vectors

 AREA |.text|, CODE, READONLY

; Reset handler
Reset_Handler PROC
 EXPORT Reset_Handler [WEAK]
 IMPORT __main
 IMPORT SystemInit
 LDR R0, =SystemInit
 BLX R0
 LDR R0, =__main
 BX R0
 ENDP

; Dummy Exception Handlers (infinite loops which can be modified)

NMI_Handler PROC
 EXPORT NMI_Handler [WEAK]
 B .
 ENDP
HardFault_Handler\
 PROC
 EXPORT HardFault_Handler [WEAK]
 B .
 ENDP
MemManage_Handler\
 PROC
 EXPORT MemManage_Handler [WEAK]
 B .
 ENDP
BusFault_Handler\
 PROC
 EXPORT BusFault_Handler [WEAK]
 B .
 ENDP
UsageFault_Handler\
 PROC
 EXPORT UsageFault_Handler [WEAK]
 B .
 ENDP
SVC_Handler PROC
 EXPORT SVC_Handler [WEAK]
 B .
 ENDP
DebugMon_Handler\
 PROC
 EXPORT DebugMon_Handler [WEAK]
 B .
 ENDP
PendSV_Handler PROC
 EXPORT PendSV_Handler [WEAK]
 B .
 ENDP
SysTick_Handler PROC
 EXPORT SysTick_Handler [WEAK]
 B .
 ENDP

Default_Handler PROC

 EXPORT WWDG_IRQHandler [WEAK]
 EXPORT PVD_IRQHandler [WEAK]
 EXPORT TAMPER_IRQHandler [WEAK]
 EXPORT RTC_IRQHandler [WEAK]
 EXPORT FLASH_IRQHandler [WEAK]
 EXPORT RCC_IRQHandler [WEAK]
 EXPORT EXTI0_IRQHandler [WEAK]
 EXPORT EXTI1_IRQHandler [WEAK]
 EXPORT EXTI2_IRQHandler [WEAK]
 EXPORT EXTI3_IRQHandler [WEAK]
 EXPORT EXTI4_IRQHandler [WEAK]
 EXPORT DMA1_Channel1_IRQHandler [WEAK]
 EXPORT DMA1_Channel2_IRQHandler [WEAK]
 EXPORT DMA1_Channel3_IRQHandler [WEAK]
 EXPORT DMA1_Channel4_IRQHandler [WEAK]
 EXPORT DMA1_Channel5_IRQHandler [WEAK]
 EXPORT DMA1_Channel6_IRQHandler [WEAK]
 EXPORT DMA1_Channel7_IRQHandler [WEAK]
 EXPORT ADC1_2_IRQHandler [WEAK]
 EXPORT USB_HP_CAN1_TX_IRQHandler [WEAK]
 EXPORT USB_LP_CAN1_RX0_IRQHandler [WEAK]
 EXPORT CAN1_RX1_IRQHandler [WEAK]
 EXPORT CAN1_SCE_IRQHandler [WEAK]
 EXPORT EXTI9_5_IRQHandler [WEAK]
 EXPORT TIM1_BRK_IRQHandler [WEAK]
 EXPORT TIM1_UP_IRQHandler [WEAK]
 EXPORT TIM1_TRG_COM_IRQHandler [WEAK]
 EXPORT TIM1_CC_IRQHandler [WEAK]
 EXPORT TIM2_IRQHandler [WEAK]
 EXPORT TIM3_IRQHandler [WEAK]
 EXPORT TIM4_IRQHandler [WEAK]
 EXPORT I2C1_EV_IRQHandler [WEAK]
 EXPORT I2C1_ER_IRQHandler [WEAK]
 EXPORT I2C2_EV_IRQHandler [WEAK]
 EXPORT I2C2_ER_IRQHandler [WEAK]
 EXPORT SPI1_IRQHandler [WEAK]
 EXPORT SPI2_IRQHandler [WEAK]
 EXPORT USART1_IRQHandler [WEAK]
 EXPORT USART2_IRQHandler [WEAK]
 EXPORT USART3_IRQHandler [WEAK]
 EXPORT EXTI15_10_IRQHandler [WEAK]
 EXPORT RTCAlarm_IRQHandler [WEAK]
 EXPORT USBWakeUp_IRQHandler [WEAK]
 EXPORT TIM8_BRK_IRQHandler [WEAK]
 EXPORT TIM8_UP_IRQHandler [WEAK]
 EXPORT TIM8_TRG_COM_IRQHandler [WEAK]
 EXPORT TIM8_CC_IRQHandler [WEAK]
 EXPORT ADC3_IRQHandler [WEAK]
 EXPORT FSMC_IRQHandler [WEAK]
 EXPORT SDIO_IRQHandler [WEAK]
 EXPORT TIM5_IRQHandler [WEAK]
 EXPORT SPI3_IRQHandler [WEAK]
 EXPORT UART4_IRQHandler [WEAK]
 EXPORT UART5_IRQHandler [WEAK]
 EXPORT TIM6_IRQHandler [WEAK]
 EXPORT TIM7_IRQHandler [WEAK]
 EXPORT DMA2_Channel1_IRQHandler [WEAK]
 EXPORT DMA2_Channel2_IRQHandler [WEAK]
 EXPORT DMA2_Channel3_IRQHandler [WEAK]
 EXPORT DMA2_Channel4_5_IRQHandler [WEAK]

WWDG_IRQHandler
PVD_IRQHandler
TAMPER_IRQHandler
RTC_IRQHandler
FLASH_IRQHandler
RCC_IRQHandler
EXTI0_IRQHandler
EXTI1_IRQHandler
EXTI2_IRQHandler
EXTI3_IRQHandler
EXTI4_IRQHandler
DMA1_Channel1_IRQHandler
DMA1_Channel2_IRQHandler
DMA1_Channel3_IRQHandler
DMA1_Channel4_IRQHandler
DMA1_Channel5_IRQHandler
DMA1_Channel6_IRQHandler
DMA1_Channel7_IRQHandler
ADC1_2_IRQHandler
USB_HP_CAN1_TX_IRQHandler
USB_LP_CAN1_RX0_IRQHandler
CAN1_RX1_IRQHandler
CAN1_SCE_IRQHandler
EXTI9_5_IRQHandler
TIM1_BRK_IRQHandler
TIM1_UP_IRQHandler
TIM1_TRG_COM_IRQHandler
TIM1_CC_IRQHandler
TIM2_IRQHandler
TIM3_IRQHandler
TIM4_IRQHandler
I2C1_EV_IRQHandler
I2C1_ER_IRQHandler
I2C2_EV_IRQHandler
I2C2_ER_IRQHandler
SPI1_IRQHandler
SPI2_IRQHandler
USART1_IRQHandler
USART2_IRQHandler
USART3_IRQHandler
EXTI15_10_IRQHandler
RTCAlarm_IRQHandler
USBWakeUp_IRQHandler
TIM8_BRK_IRQHandler
TIM8_UP_IRQHandler
TIM8_TRG_COM_IRQHandler
TIM8_CC_IRQHandler
ADC3_IRQHandler
FSMC_IRQHandler
SDIO_IRQHandler
TIM5_IRQHandler
SPI3_IRQHandler
UART4_IRQHandler
UART5_IRQHandler
TIM6_IRQHandler
TIM7_IRQHandler
DMA2_Channel1_IRQHandler
DMA2_Channel2_IRQHandler
DMA2_Channel3_IRQHandler
DMA2_Channel4_5_IRQHandler
 B .

 ENDP

 ALIGN

;*******************************************************************************
; User Stack and Heap initialization
;*******************************************************************************
 IF :DEF:__MICROLIB

 EXPORT __initial_sp
 EXPORT __heap_base
 EXPORT __heap_limit

 ELSE

 IMPORT __use_two_region_memory
 EXPORT __user_initial_stackheap

__user_initial_stackheap

 LDR R0, = Heap_Mem
 LDR R1, =(Stack_Mem + Stack_Size)
 LDR R2, = (Heap_Mem + Heap_Size)
 LDR R3, = Stack_Mem
 BX LR

 ALIGN

 ENDIF

 END

;******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE*****

1. 代码解释

main.c - 主程序文件这是一个简单的LED闪烁程序：配置GPIOC的Pin2作为LED控制引脚在主循环中通过GPIO_SetBits和GPIO_ResetBits来控制LED的亮灭使用Delay函数实现延时

startup_stm32f10x_hd.s - 启动文件这是STM32的汇编启动文件，主要功能包括：设置堆栈指针配置中断向量表初始化系统时钟跳转到C语言main函数

stm32f10x.h - 寄存器定义文件定义了STM32的硬件寄存器映射：定义了外设基地址（PERIPH_BASE等）定义了GPIO和RCC等外设的寄存器结构体提供了访问这些寄存器的指针定义

stm32f10x_gpio.c/.h - GPIO驱动文件提供GPIO操作的函数实现： GPIO_Init：初始化GPIO引脚的模式和速度 GPIO_SetBits：设置引脚高电平 GPIO_ResetBits：设置引脚低电平关键的GPIO模式定义： typedef enum { GPIO_Mode_AIN = 0x0, // 模拟输入 GPIO_Mode_IN_FLOATING = 0x04, // 浮空输入 GPIO_Mode_IPD = 0x28, // 下拉输入 GPIO_Mode_IPU = 0x48, // 上拉输入 GPIO_Mode_Out_OD = 0x14, // 开漏输出 GPIO_Mode_Out_PP = 0x10, // 推挽输出 GPIO_Mode_AF_OD = 0x1C, // 复用开漏输出 GPIO_Mode_AF_PP = 0x18 // 复用推挽输出 }GPIOMode_TypeDef; 这是一个典型的STM32F10x系列单片机的基础程序，实现了最基本的GPIO控制功能，可以控制LED的亮灭。程序的结构清晰，包含了完整的底层驱动实现。

10 初识stm32固件库

如何下载固件库

11 新建项目，固件库版本（开始使用固件库编程）

一般结构如下

可以在这里改名

创建好文件夹还不行，还需要在keil中指定文件目录

爬虫-实战-爬取arXiv AI论文对应的url和title等

Thu, 20 Mar 2025 10:59:07 +0800

教程：使用 Python 爬取 arXiv AI 论文 / Tutorial: Crawling arXiv AI Papers with Python

代码文件和实例arXiv的html文件
爬虫代码
json输出
html示例

在本教程中，您将学习如何使用 Python 从 arXiv（一个流行的研究论文库）爬取最新的人工智能（AI）论文，并将结果保存为 JSON 文件。我们将逐步拆解代码，解释其功能，并告诉您如何根据需要进行修改。

In this tutorial, you’ll learn how to use Python to scrape the latest Artificial Intelligence (AI) papers from arXiv (a popular repository of research papers) and save the results in a JSON file. We’ll break down the code step by step, explaining its functionality and how you can modify it for your needs.

前提条件 / Prerequisites

开始之前，请确保您已安装以下内容：
Before you begin, ensure you have the following installed:

Python 3.x: 我们将使用的编程语言 / The programming language we’ll use.
库 / Libraries:
- requests: 用于发送 HTTP 请求获取网页 / For making HTTP requests to fetch web pages.
- beautifulsoup4: 用于解析 HTML 内容 / For parsing HTML content.
- json: Python 内置库，用于处理 JSON 数据 / Built-in Python library for working with JSON data.

安装所需库（使用 pip）：
Install the required libraries using pip:

pip install requests beautifulsoup4

代码功能 / What the Code Does

这个脚本会：
The script:

从 arXiv 的 AI 新论文页面 (https://arxiv.org/list/cs.AI/new) 获取最新论文。
Fetches the latest AI papers from the arXiv page (https://arxiv.org/list/cs.AI/new).
提取每篇论文的详细信息，例如标题、摘要、作者、评论和学科分类。
Extracts details like title, abstract, authors, comments, and subjects for each paper.
将数据保存到 JSON 文件 (arxiv_papers.json)。
Saves the data in a JSON file (arxiv_papers.json).

让我们深入代码！
Let’s dive into the code!

第一步：导入库 / Step 1: Importing Libraries

import requests
from bs4 import BeautifulSoup
import json
import time

requests: 发送 HTTP 请求以获取网页内容 / Sends HTTP requests to fetch the webpage.
BeautifulSoup: 解析网页的 HTML 内容 / Parses the HTML content of the webpage.
json: 处理 JSON 格式的数据保存 / Handles saving the scraped data in JSON format.
time: 本脚本未使用，但可用于将来添加延迟 / Not used in this script but imported for potential future use (e.g., adding delays).

第二步：设置参数 / Step 2: Setting Configuration Parameters

START_URL = "https://arxiv.org/list/cs.AI/new" # arXiv AI 新论文页面 / arXiv AI new papers page
OUTPUT_FILE = "arxiv_papers.json" # 输出文件名 / Output filename

START_URL: 我们要爬取的网页（arXiv 的 AI 新论文页面）。
The webpage we want to scrape (new AI papers on arXiv).
OUTPUT_FILE: 保存爬取数据的文件名。
The name of the file where the scraped data will be saved.

修改建议 / Tip: 您可以更改 START_URL 来爬取其他 arXiv 类别，例如 cs.LG（机器学习）。
You can modify START_URL to scrape a different arXiv category (e.g., cs.LG for Machine Learning).

第三步：定义爬取函数 / Step 3: Defining the Crawling Function

def crawl_arxiv_papers():
 print(f"开始爬取: {START_URL}")

 try:
 # 发送 HTTP 请求 / Send HTTP request
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(START_URL, headers=headers, timeout=20)
 response.raise_for_status()

crawl_arxiv_papers(): 执行爬取的主要函数 / The main function that performs the scraping.
headers: 模拟浏览器请求，避免被服务器阻止 / Mimics a browser request to avoid being blocked by the server.
requests.get(): 获取网页内容，设置 20 秒超时 / Fetches the webpage content with a 20-second timeout.
raise_for_status(): 如果请求失败（例如 404 错误），抛出异常 / Raises an exception if the request fails (e.g., 404 error).

解析 HTML / Parsing the HTML

 soup = BeautifulSoup(response.text, "html.parser")

 papers = []

 dt_tags = soup.find_all("dt")

BeautifulSoup: 将 HTML 内容解析为可操作的结构 / Parses the HTML content into a navigable structure.
papers: 存储爬取结果的列表 / A list to store the scraped paper data.
dt_tags: 查找所有 <dt> 标签，每篇论文的条目从这里开始 / Finds all <dt> tags, which mark the start of each paper entry on the arXiv page.

提取论文详情 / Extracting Paper Details

 for dt_tag in dt_tags:
 dd_tag = dt_tag.find_next_sibling("dd")
 if not dd_tag:
 continue

 paper = {}

遍历每个 <dt> 标签，找到对应的 <dd> 标签（包含元数据）。
Loops through each <dt> tag and finds its sibling <dd> tag (contains metadata).
paper: 存储单篇论文详情的字典 / A dictionary to store details of a single paper.

提取论文链接和 ID / Extracting Paper URL and ID

 paper_link = dt_tag.find("a", href=True, title="Abstract")
 if paper_link:
 paper["arxiv_url"] = paper_link["href"]
 paper["arxiv_id"] = paper_link.text.strip()

找到 <dt> 中的摘要链接，提取 URL 和 arXiv ID（例如 arXiv:XXXX.XXXX）。
Finds the abstract link in <dt> and extracts the URL and arXiv ID (e.g., arXiv:XXXX.XXXX).

提取元数据 / Extracting Metadata

 meta_div = dd_tag.find("div", class_="meta")
 if not meta_div:
 continue

在 <dd> 中找到 <div class="meta">，它包含论文的详细信息。
Finds the <div class="meta"> inside <dd>, which holds the paper’s details.

标题 / Title

 title_div = meta_div.find("div", class_="list-title mathjax")
 if title_div:
 title_text = title_div.get_text(strip=True)
 if "Title:" in title_text:
 title_text = title_text.split("Title:", 1)[1].strip()
 paper["title"] = title_text

提取论文标题并移除 “Title:” 前缀。
Extracts the paper title and removes the “Title:” prefix.

摘要 / Abstract

 abstract = meta_div.find("p", class_="mathjax")
 if abstract:
 paper["abstract"] = abstract.get_text(strip=True)

提取论文摘要。
Extracts the abstract text.

评论（可选） / Comments (Optional)

 comments_div = meta_div.find("div", class_="list-comments mathjax")
 if comments_div:
 comments_text = comments_div.get_text(strip=True)
 if "Comments:" in comments_text:
 comments_text = comments_text.split("Comments:", 1)[1].strip()
 paper["comments"] = comments_text

如果存在评论（例如 “10 pages, 3 figures”），则提取它。
Extracts comments if they exist (e.g., “10 pages, 3 figures”).

作者 / Authors

 authors_div = meta_div.find("div", class_="list-authors")
 if authors_div:
 authors = [a.get_text(strip=True) for a in authors_div.find_all("a")]
 paper["authors"] = authors

提取作者列表。
Extracts a list of author names.

学科分类 / Subjects

 subjects_div = meta_div.find("div", class_="list-subjects")
 if subjects_div:
 subjects_text = subjects_div.get_text(strip=True)
 if "Subjects:" in subjects_text:
 subjects_text = subjects_text.split("Subjects:", 1)[1].strip()
 paper["subjects"] = subjects_text

提取学科分类（例如 “Artificial Intelligence (cs.AI)"）。
Extracts the subject categories (e.g., “Artificial Intelligence (cs.AI)”).

添加到列表 / Adding to List

 if paper:
 papers.append(paper)

将论文字典添加到 papers 列表中。
Adds the paper dictionary to the papers list.

错误处理 / Error Handling

 except requests.RequestException as e:
 print(f"爬取失败: {e}")
 return []

捕获网络相关的错误，如果请求失败则返回空列表。
Catches network-related errors and returns an empty list if the request fails.

第四步：保存数据到文件 / Step 4: Saving Data to a File

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

save_to_file(): 将爬取的数据写入 JSON 文件。
Writes the scraped data to a JSON file.
ensure_ascii=False: 保留非 ASCII 字符（例如中文或特殊符号）。
Preserves non-ASCII characters (e.g., Chinese or special symbols).
indent=4: 格式化 JSON 文件以便阅读。
Formats the JSON file for readability.

第五步：主函数和执行 / Step 5: Main Function and Execution

def main():
 print("开始爬虫程序...")
 papers = crawl_arxiv_papers()

 if papers:
 save_to_file(papers, OUTPUT_FILE)
 print(f"爬取完成，共获取 {len(papers)} 篇论文信息")
 else:
 print("未获取到任何论文信息")

if __name__ == "__main__":
 main()

main(): 协调爬取和保存过程。
Orchestrates the crawling and saving process.
if __name__ == "__main__": 确保脚本仅在直接运行时执行（而不是被导入时）。
Ensures the script runs only when executed directly (not when imported).

运行代码 / Running the Code

将代码保存到文件（例如 arxiv_crawler.py）。
Save the code in a file (e.g., arxiv_crawler.py).
在同一目录下打开终端。
Open a terminal in the same directory.
运行脚本：
Run the script:
```
python arxiv_crawler.py
```
检查输出文件 arxiv_papers.json 查看结果。
Check the output file arxiv_papers.json for the results.

示例输出 / Sample Output

arxiv_papers.json 文件可能如下所示：
The arxiv_papers.json file might look like this:

[
 {
 "arxiv_url": "/abs/2503.12345",
 "arxiv_id": "arXiv:2503.12345",
 "title": "A New AI Model",
 "abstract": "This paper introduces...",
 "authors": ["John Doe", "Jane Smith"],
 "subjects": "Artificial Intelligence (cs.AI)"
 },
 ...
]

自定义建议 / Tips for Customization

更改类别 / Change Category: 修改 START_URL 来爬取其他 arXiv 类别（例如 https://arxiv.org/list/cs.LG/new 用于机器学习）。
Modify START_URL to scrape a different arXiv category (e.g., https://arxiv.org/list/cs.LG/new for Machine Learning).
添加延迟 / Add Delays: 在循环中加入 time.sleep(2) 以避免对服务器造成过大压力。
Use time.sleep(2) in the loop to avoid overwhelming the server.
错误日志 / Error Logging: 使用日志记录代替 print 语句，以便更好地调试。
Add logging instead of print statements for better debugging.

爬虫-实战-多页面递归爬取

Thu, 20 Mar 2025 10:20:00 +0800

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

# 配置爬虫参数
START_URL = "https://arxiv.org/list/cs.AI/new" # 替换为你想爬取的起始URL
MAX_DEPTH = 1 # 最大爬取深度
OUTPUT_FILE = "crawled_data.json" # 输出文件名

# 用于存储已访问的URL，避免重复
visited_urls = set()

# 用于存储爬取结果
crawled_data = []

def crawl(url, depth=0):
 # 检查深度限制和是否已访问
 if depth > MAX_DEPTH or url in visited_urls:
 return

 print(f"正在爬取: {url} (深度: {depth})")

 try:
 # 发送HTTP请求
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(url, headers=headers, timeout=20)
 response.raise_for_status() # 检查请求是否成功

 # 标记为已访问
 visited_urls.add(url)

 # 解析HTML内容
 soup = BeautifulSoup(response.text, "html.parser")

 # 提取当前页面的标题作为主要内容（可以根据需要修改）
 page_title = soup.title.string if soup.title else "无标题"

 # 提取页面中的内容
 content = soup.get_text()

 # 存储当前页面的URL和内容
 crawled_data.append({
 "url": url,
 "title": page_title,
 "depth": depth,
 "content": content
 })

 # 提取页面中的所有链接
 for link in soup.find_all("a", href=True):
 href = link.get("href")
 link_text = link.text.strip() or "无文本"

 # 将相对URL转换为绝对URL
 absolute_url = urljoin(url, href)

 # 简单过滤，只爬取http或https链接
 if absolute_url.startswith(("http://", "https://")):
 # 递归爬取新链接
 crawl(absolute_url, depth + 1)

 # 避免过于频繁请求，礼貌爬取
 time.sleep(1)

 except requests.RequestException as e:
 print(f"爬取 {url} 失败: {e}")

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

def main():
 print("开始爬取...")
 crawl(START_URL)
 save_to_file(crawled_data, OUTPUT_FILE)
 print(f"爬取完成，共爬取 {len(crawled_data)} 个页面")

if __name__ == "__main__":
 main()

1. 代码概述

这个爬虫使用 requests 获取网页内容，BeautifulSoup 解析 HTML，然后递归爬取页面中的链接，最终将结果保存为 JSON 文件。主要功能包括：

从指定起始 URL 开始爬取。
限制爬取深度，避免无限递归。
提取页面标题和文本内容。
保存爬取结果到本地文件。

2. 导入库

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

requests：用于发送 HTTP 请求获取网页内容。
BeautifulSoup（来自 bs4）：解析 HTML 内容，提取所需数据。
json：将爬取结果保存为 JSON 格式。
urljoin（来自 urllib.parse）：将相对 URL 转换为绝对 URL。
time：用于添加延迟，避免过于频繁请求服务器。

3. 配置爬虫参数

START_URL = "https://arxiv.org/list/cs.AI/new" # 替换为你想爬取的起始URL
MAX_DEPTH = 1 # 最大爬取深度
OUTPUT_FILE = "crawled_data.json" # 输出文件名

START_URL：爬虫的起始页面，这里是 arXiv 的 AI 分类新论文页面。
MAX_DEPTH：限制递归爬取的深度，防止爬虫无限扩展（这里设为 1，只爬取起始页面和其直接链接）。
OUTPUT_FILE：结果保存的文件名。

4. 全局变量

visited_urls = set()
crawled_data = []

visited_urls：一个集合（set），记录已访问的 URL，避免重复爬取。
crawled_data：一个列表，存储所有爬取到的页面数据。

5. 主爬取函数 `crawl`

def crawl(url, depth=0):

url：要爬取的网页地址。
depth：当前爬取的深度，默认从 0 开始。

5.1 检查条件

if depth > MAX_DEPTH or url in visited_urls:
 return

如果当前深度超过 MAX_DEPTH 或 URL 已访问过，则停止爬取并返回。

5.2 发送请求

print(f"正在爬取: {url} (深度: {depth})")
try:
 headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
 response = requests.get(url, headers=headers, timeout=20)
 response.raise_for_status() # 检查请求是否成功

打印当前爬取的 URL 和深度。
使用 requests.get 发送 HTTP GET 请求：
- headers：伪装成浏览器，避免被服务器拒绝。
- timeout=20：设置 20 秒超时，防止请求挂起。
raise_for_status()：如果请求失败（比如 404 或 500），抛出异常。

5.3 标记已访问

visited_urls.add(url)

将当前 URL 添加到 visited_urls 集合，避免重复爬取。

5.4 解析 HTML

soup = BeautifulSoup(response.text, "html.parser")

使用 BeautifulSoup 将网页的 HTML 内容解析为可操作的对象。

5.5 提取标题和内容

page_title = soup.title.string if soup.title else "无标题"
content = soup.get_text()

page_title：提取页面的 <title> 标签内容，如果没有则设为“无标题”。
content：提取页面所有文本内容（去掉 HTML 标签）。

5.6 保存数据

crawled_data.append({
 "url": url,
 "title": page_title,
 "depth": depth,
 "content": content
})

将当前页面的信息（URL、标题、深度、内容）存入 crawled_data 列表。

5.7 提取并递归爬取链接

for link in soup.find_all("a", href=True):
 href = link.get("href")
 link_text = link.text.strip() or "无文本"
 absolute_url = urljoin(url, href)
 if absolute_url.startswith(("http://", "https://")):
 crawl(absolute_url, depth + 1)

soup.find_all("a", href=True)：查找页面中所有带 href 属性的 <a> 标签（超链接）。
href：获取链接地址。
link_text：获取链接的文本内容，若为空则设为“无文本”。
urljoin(url, href)：将相对链接（如 /about）转换为绝对链接（如 https://arxiv.org/about）。
如果链接以 http:// 或 https:// 开头，则递归调用 crawl，深度加 1。

5.8 延迟

time.sleep(1)

每次请求后暂停 1 秒，避免对服务器造成过大压力（礼貌爬取）。

5.9 错误处理

except requests.RequestException as e:
 print(f"爬取 {url} 失败: {e}")

如果请求失败（如超时或 404），打印错误信息。

6. 保存数据函数 `save_to_file`

def save_to_file(data, filename):
 with open(filename, "w", encoding="utf-8") as f:
 json.dump(data, f, ensure_ascii=False, indent=4)
 print(f"数据已保存到 {filename}")

json.dump：将数据以 JSON 格式写入文件。
ensure_ascii=False：支持非 ASCII 字符（如中文）。
indent=4：格式化 JSON，使其更易读。

7. 主函数 `main`

def main():
 print("开始爬取...")
 crawl(START_URL)
 save_to_file(crawled_data, OUTPUT_FILE)
 print(f"爬取完成，共爬取 {len(crawled_data)} 个页面")

调用 crawl 开始爬取。
保存结果到文件。
打印爬取的总页面数。

8. 运行代码

if __name__ == "__main__":
 main()

确保代码只在直接运行脚本时执行（而不是被导入时）。

9. 运行示例

安装依赖：
```
pip install requests beautifulsoup4
```
运行代码：
- 爬虫从 https://arxiv.org/list/cs.AI/new 开始。
- 爬取该页面及其直接链接（深度 ≤ 1）。
- 结果保存到 crawled_data.json。

输出文件示例：

[
 {
 "url": "https://arxiv.org/list/cs.AI/new",
 "title": "New submissions for cs.AI",
 "depth": 0,
 "content": "...页面文本内容..."
 },
 {
 "url": "https://arxiv.org/abs/1234.56789",
 "title": "Paper Title",
 "depth": 1,
 "content": "...论文摘要等内容..."
 }
]

10. 注意事项

礼貌爬取：time.sleep(1) 避免过于频繁请求，但可以根据网站政策调整。
robots.txt：检查目标网站的 robots.txt（如 https://arxiv.org/robots.txt），确保遵守规则。
异常处理：当前只处理了请求相关的异常，可根据需要扩展。
内容提取：当前提取所有文本（get_text()），可改为提取特定元素（如论文标题、摘要）。

11. 改进建议

过滤链接：添加域名限制（如只爬 arxiv.org 的链接）。
多线程：使用 threading 或 asyncio 加速爬取。
数据清洗：去掉无关内容（如页脚、导航栏）。
代理支持：添加代理池以应对封禁。

给hugo博客的页面增加一个自定义密码（防君子不防小人）

Wed, 05 Mar 2025 17:14:05 +0800

在 Hugo 的 Stack 模板中为特定文章添加自定义密码保护并不是 Hugo 内置的功能，但可以通过结合 Hugo 的前端功能和一些自定义逻辑来实现。以下是一个分步指南，帮助你在 Stack 模板中为某些文章添加密码保护：

在页面当中添加一个密码验证（由于静态页面的特性，仍有方法在没有密码的情况下解除锁定，所以此方法不要当真,防君子不防小人）

1. 前提条件

你需要对 Hugo 的模板文件（如 .html 文件）有一定了解。
你需要编辑 Stack 模板的代码（通常位于 themes/Stack 目录下）。
每篇文章的密码在Front Matter 中定义。

2. 为文章添加密码字段

在需要密码保护的文章的 Front Matter 中添加一个自定义字段，例如 password。例如：

---
title: "受保护的文章"
date: 2025-03-05
password: "mysecretpassword" # 自定义密码
---
这是一篇受保护的文章内容。

如果某篇文章没有 password 字段，则默认不启用密码保护。

3. 修改模板文件

Stack 模板通常使用 layouts 文件夹中的模板来渲染文章页面。你需要修改渲染单篇文章的模板（通常是 themes/Stack/layouts/_default/single.html）。

示例修改：

在 single.html 中添加逻辑，检查文章是否有密码，并要求用户输入密码。以下是一个基本的实现思路：

{{ define "body-class" }}
 article-page
 {{/*
 Enable the right sidebar if
 - Widget different from 'TOC' is enabled
 - TOC is enabled and not empty
 */}}
 {{- $HasWidgetNotTOC := false -}}
 {{- $TOCWidgetEnabled := false -}}
 {{- range .Site.Params.widgets.page -}}
 {{- if ne .type "toc" -}}
 {{ $HasWidgetNotTOC = true -}}
 {{- else -}}
 {{ $TOCWidgetEnabled = true -}}
 {{- end -}}
 {{- end -}}

 {{- $TOCManuallyDisabled := eq .Params.toc false -}}
 {{- $TOCEnabled := and (not $TOCManuallyDisabled) $TOCWidgetEnabled -}}
 {{- $hasTOC := ge (len .TableOfContents) 100 -}}
 {{- .Scratch.Set "TOCEnabled" (and $TOCEnabled $hasTOC) -}}

 {{- .Scratch.Set "hasWidget" (or $HasWidgetNotTOC (and $TOCEnabled $hasTOC)) -}}
{{ end }}






{{ define "main" }}



 {{ if .Params.password }}
 <div id="password-prompt">
 <p>请输入密码以查看内容：</p>
 <input type="password" id="password-input" />
 <button onclick="checkPassword()">提交</button>
 </div>
 <div id="content" class="content" style="display: none;">
 {{ partial "article/article.html" . }}
 {{ if .Params.links }}
 {{ partial "article/components/links" . }}
 {{ end }}

 {{ partial "article/components/related-content" . }}

 {{ if not (eq .Params.comments false) }}
 {{ partial "comments/include" . }}
 {{ end }}

 {{ partialCached "footer/footer" . }}

 {{ partialCached "article/components/photoswipe" . }}
 </div>
 <script>
 function checkPassword() {
 const input = document.getElementById("password-input").value;
 const correctPassword = "{{ .Params.password }}";
 if (input === correctPassword) {
 document.getElementById("password-prompt").style.display = "none";
 document.getElementById("content").style.display = "block";
 } else {
 alert("密码错误！");
 }
 }
 </script>
 {{ else }}
 {{ partial "article/article.html" . }}
 {{ if .Params.links }}
 {{ partial "article/components/links" . }}
 {{ end }}

 {{ partial "article/components/related-content" . }}

 {{ if not (eq .Params.comments false) }}
 {{ partial "comments/include" . }}
 {{ end }}

 {{ partialCached "footer/footer" . }}

 {{ partialCached "article/components/photoswipe" . }}

 {{ end }}
{{ end }}


{{ define "right-sidebar" }}
 {{ if not .Params.password }}
 {{ if .Scratch.Get "hasWidget" }}{{ partial "sidebar/right.html" (dict "Context" . "Scope" "page") }}{{ end}}
 {{ end }}
{{ end }}

下面是single.html中原本的内容


<!--
{{ define "body-class" }}
 article-page
 {{/*
 Enable the right sidebar if
 - Widget different from 'TOC' is enabled
 - TOC is enabled and not empty
 */}}
 {{- $HasWidgetNotTOC := false -}}
 {{- $TOCWidgetEnabled := false -}}
 {{- range .Site.Params.widgets.page -}}
 {{- if ne .type "toc" -}}
 {{ $HasWidgetNotTOC = true -}}
 {{- else -}}
 {{ $TOCWidgetEnabled = true -}}
 {{- end -}}
 {{- end -}}

 {{- $TOCManuallyDisabled := eq .Params.toc false -}}
 {{- $TOCEnabled := and (not $TOCManuallyDisabled) $TOCWidgetEnabled -}}
 {{- $hasTOC := ge (len .TableOfContents) 100 -}}
 {{- .Scratch.Set "TOCEnabled" (and $TOCEnabled $hasTOC) -}}

 {{- .Scratch.Set "hasWidget" (or $HasWidgetNotTOC (and $TOCEnabled $hasTOC)) -}}
{{ end }}

{{ define "main" }}
 {{ partial "article/article.html" . }}

 {{ if .Params.links }}
 {{ partial "article/components/links" . }}
 {{ end }}

 {{ partial "article/components/related-content" . }}

 {{ if not (eq .Params.comments false) }}
 {{ partial "comments/include" . }}
 {{ end }}

 {{ partialCached "footer/footer" . }}

 {{ partialCached "article/components/photoswipe" . }}
{{ end }}

{{ define "right-sidebar" }}
 {{ if .Scratch.Get "hasWidget" }}{{ partial "sidebar/right.html" (dict "Context" . "Scope" "page") }}{{ end}}
{{ end }} -->

解释：

{{ if .Params.password }} 检查文章是否有 password 参数。
如果有，则显示一个密码输入框和提交按钮，内容默认隐藏。
用户输入密码后，JavaScript 会验证输入是否与文章的密码匹配。如果匹配，则显示内容；否则提示错误。
如果没有密码，则直接显示文章内容。

注意事项

静态网站限制：Hugo 生成的是静态网站，密码保护本质上是前端逻辑，安全性有限。如果需要真正的访问控制，建议使用 CMS 或动态后端。
Stack 模板兼容性：确保你的修改不会与 Stack 模板的现有样式或脚本冲突。如果有问题，可能需要调整 CSS 或 JavaScript。

hugo使用过程中遇到的问题

Wed, 05 Mar 2025 16:22:44 +0800

github action 遇到的问题

github action提示 you can try to increase the ’timeout’ config setting.

解决方法就是在这里增加一个timeout参数，可以把时间设置大一些

5-引入 Giscus 评论系统

Wed, 05 Mar 2025 14:46:18 +0800

参考：

https://www.lixueduan.com/posts/blog/02-add-giscus-comment/#1-%E9%80%89%E6%8B%A9%E4%B8%80%E4%B8%AA%E8%AF%84%E8%AE%BA%E7%B3%BB%E7%BB%9F

Stack 主题

1. 登录绑定应用

https://github.com/apps/giscus

然后选择你需要绑定的仓库

2.进入仓库开启Discussions

3.获取配置信息

进到下面的这个网站里面

https://giscus.app/zh-CN

然后按照这样配置就可以得到最后的配置文件

4.回到hugo.yaml把刚刚的配置填进去

红框里面是要改的地方

碰到的坑

上面的参考文章里面写的页面–discussion映射关系是使用pathname，但是我发现会乱码，就改成用title了

4-自定义Python函数创建博客：告别繁琐的文件头输入

Mon, 03 Mar 2025 16:32:39 +0800

以下是基于最新的需求重新撰写的博客文章，主题仍是“使用自定义Python函数创建博客，避免繁琐的文件头标准内容输入”。这次博客将反映新的功能：通过 categories、tags 和 title 三个参数生成文件夹和文件，并将路径组合为 categories/tags/title。

使用自定义Python函数创建博客：告别繁琐的文件头输入

在维护技术博客时，每次创建新文章都需要手动设置文件夹结构和标准化的Markdown文件头，例如标题、分类、标签和日期等。这种重复劳动不仅耗时，还容易出错。想象一下，如果能通过一个简单的命令，比如 zata create -c Python -t github -b MyProject，自动生成带有标准头部的博客文件，并按分类和标签组织目录结构，会不会让写作更高效？

在这篇博客中，我将展示如何用Python实现这一自动化工具，并将其打包成一个命令行可执行文件。通过自定义函数，我们可以轻松创建博客文件，避免手动输入繁琐的文件头内容。

背景与目标

假设你正在用静态网站生成器（如Jekyll或Hugo）写博客，每次新建文章时需要：

创建一个文件夹结构，比如 Python/github/MyProject。
在最内层文件夹中生成一个 index.md 文件。

为 index.md 添加标准头部，例如：

---
title: MyProject
description: "空"
date: 2025-03-03T15:20:45+08:00
image: images/index.png
categories:
 - Python
tags:
 - github
---

手动完成这些步骤虽然可行，但效率低下。我的目标是：

编写一个Python脚本，接受 categories、tags 和 title 三个参数。
根据输入生成路径 categories/tags/title，并创建对应的文件夹和 index.md 文件。
自动填充标准头部信息，日期使用当前时间。
将脚本打包成命令行工具，支持 zata create -c [分类] -t [标签] -b [标题] 的调用方式。

2025.03.03 初步实现可以使用命令行创建一个博客

步骤 1：设计基本功能

我们需要一个函数，根据输入的 categories、tags 和 title 创建文件夹和文件。以下是最小化的实现：

import os
from datetime import datetime

def create_folder_and_md(categories, tags, title):
 current_dir = os.getcwd()
 target_path = os.path.join(current_dir, categories, tags, title)
 current_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%S+08:00")

 os.makedirs(target_path, exist_ok=True)
 md_file_path = os.path.join(target_path, "index.md")
 header_content = f"""---
title: {title}
description: "空"
date: {current_time}
image: images/index.png
categories:
 - {categories}
tags:
 - {tags}
---
"""
 with open(md_file_path, 'w', encoding='utf-8') as f:
 f.write(header_content)
 print(f"文件夹 '{target_path}' 和 'index.md' 创建成功！")

create_folder_and_md("Python", "github", "MyProject")

这个脚本会在当前目录下创建 Python/github/MyProject 文件夹，并在其中生成带有标准头部的 index.md。

步骤 2：添加命令行支持

为了让脚本更实用，我们引入 argparse 模块，支持命令行参数输入：

import os
from datetime import datetime
import argparse

def create_folder_and_md(categories, tags, title):
 current_dir = os.getcwd()
 target_path = os.path.join(current_dir, categories, tags, title)
 current_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%S+08:00")

 try:
 os.makedirs(target_path, exist_ok=True)
 md_file_path = os.path.join(target_path, "index.md")
 header_content = f"""---
title: {title}
description: "空"
date: {current_time}
image: images/index.png
categories:
 - {categories}
tags:
 - {tags}
---
"""
 with open(md_file_path, 'w', encoding='utf-8') as f:
 f.write(header_content)
 print(f"文件夹 '{target_path}' 和 'index.md' 创建成功！")
 except Exception as e:
 print(f"发生错误: {str(e)}")

def main():
 parser = argparse.ArgumentParser(prog="zata", description="根据categories、tags和title创建一个文件夹和index.md文件")
 subparsers = parser.add_subparsers(dest="command", help="可用命令")
 create_parser = subparsers.add_parser("create", help="创建文件夹和index.md")
 create_parser.add_argument("-c", "--categories", required=True, help="博客分类")
 create_parser.add_argument("-t", "--tags", required=True, help="博客标签")
 create_parser.add_argument("-b", "--title", required=True, help="博客标题")
 args = parser.parse_args()

 if args.command == "create":
 create_folder_and_md(args.categories, args.tags, args.title)
 else:
 parser.print_help()

if __name__ == "__main__":
 main()

保存为 zata.py，运行以下命令测试：

python zata.py create -c Python -t github -b MyProject

步骤 3：打包成可执行文件

为了方便使用，我们用 PyInstaller 将脚本打包成单一的 .exe 文件：

安装 PyInstaller：
```
pip install pyinstaller
```
打包脚本：
```
pyinstaller --onefile zata.py
```
打包完成后，在 dist 文件夹中找到 zata.exe，运行：
```
zata.exe create -c Python -t github -b MyProject
```

成果展示

运行以下命令：

zata create -c Python -t github -b MyProject

结果：

生成目录结构：Python/github/MyProject。

在 MyProject 文件夹中创建 index.md，内容如下：

---
title: MyProject
description: "空"
date: 2025-03-03T15:20:45+08:00
image: images/index.png
categories:
 - Python
tags:
 - github
---

控制台输出：

文件夹 'Python/github/MyProject' 和 'index.md' 创建成功！

整个过程只需一条命令，省去了手动创建文件夹和输入文件头的麻烦。

2025.03.05 增加giu可以下拉选择来创建

import os
from datetime import datetime
import argparse
import tkinter as tk
from tkinter import ttk, messagebox

# 原有函数保持不变，返回值改为元组以适应 GUI 使用
def create_category(category):
 """创建category目录"""
 target_path = os.path.join("content", "post", category)
 try:
 os.makedirs(target_path, exist_ok=True)
 return True, f"Category目录 '{target_path}' 创建成功！"
 except Exception as e:
 return False, f"创建category时发生错误: {str(e)}"

def create_tag(category, tag):
 """创建tag目录，必须指定category"""
 base_path = os.path.join("content", "post")
 target_path = os.path.join(base_path, category, tag)

 category_path = os.path.join(base_path, category)
 if not os.path.exists(category_path):
 return False, f"错误：Category目录 '{category_path}' 不存在！请先创建category"

 try:
 os.makedirs(target_path, exist_ok=True)
 return True, f"Tag目录 '{target_path}' 创建成功！"
 except Exception as e:
 return False, f"创建tag时发生错误: {str(e)}"

def create_folder_and_md(categories, tags, title):
 """创建文章目录和index.md文件"""
 current_time = datetime.now().strftime("%Y-%m-%dT%H:%M:%S+08:00")
 base_path = os.path.join("content", "post")

 if categories:
 target_path = os.path.join(base_path, categories, tags, title)
 parent_path = os.path.join(base_path, categories, tags)

 if not os.path.exists(parent_path):
 return False, f"错误：父目录 '{parent_path}' 不存在！请先创建相应的categories和tags目录"
 else:
 matched_paths = []
 for category in os.listdir(base_path):
 category_path = os.path.join(base_path, category)
 if os.path.isdir(category_path):
 tag_path = os.path.join(category_path, tags)
 if os.path.exists(tag_path) and os.path.isdir(tag_path):
 matched_paths.append(tag_path)

 if len(matched_paths) == 0:
 return False, f"错误：未在任何category下找到tags '{tags}'！请先创建相应的tags目录"
 elif len(matched_paths) > 1:
 error_msg = f"错误：找到多个匹配的tags '{tags}'：\n"
 for path in matched_paths:
 error_msg += f" - {path}\n"
 error_msg += "请指定具体的category以避免歧义"
 return False, error_msg
 else:
 parent_path = matched_paths[0]
 target_path = os.path.join(parent_path, title)
 categories = os.path.basename(os.path.dirname(parent_path))

 try:
 os.makedirs(target_path, exist_ok=True)
 md_file_path = os.path.join(target_path, "index.md")

 header_content = f"""---
title: {title}
description: ""
date: {current_time}
image: images/index/index.png
"""
 if categories:
 header_content += f"""categories:
 - {categories}
"""
 header_content += f"""tags:
 - {tags}
---
"""

 if not os.path.exists(md_file_path):
 with open(md_file_path, 'w', encoding='utf-8') as f:
 f.write(header_content)
 return True, f"文件夹 '{target_path}' 和 'index.md' 创建成功！"
 return True, f"文件夹 '{target_path}' 已存在，跳过创建 'index.md'。"
 except Exception as e:
 return False, f"发生错误: {str(e)}"

# 新增函数：获取现有 Category 和 Tag 列表
def get_existing_categories():
 base_path = os.path.join("content", "post")
 if not os.path.exists(base_path):
 return []
 return [d for d in os.listdir(base_path) if os.path.isdir(os.path.join(base_path, d))]

def get_existing_tags(category=None):
 base_path = os.path.join("content", "post")
 if not os.path.exists(base_path):
 return []
 tags = set()
 if category:
 category_path = os.path.join(base_path, category)
 if os.path.exists(category_path):
 tags.update([d for d in os.listdir(category_path) if os.path.isdir(os.path.join(category_path, d))])
 else:
 for cat in os.listdir(base_path):
 cat_path = os.path.join(base_path, cat)
 if os.path.isdir(cat_path):
 tags.update([d for d in os.listdir(cat_path) if os.path.isdir(os.path.join(cat_path, d))])
 return sorted(list(tags))

# 修改后的 GUI
def create_gui():
 root = tk.Tk()
 root.title("Zata - 博客管理工具")
 root.geometry("500x400")

 notebook = ttk.Notebook(root)
 notebook.pack(pady=10, fill="both", expand=True)

 # Category选项卡
 category_frame = ttk.Frame(notebook)
 notebook.add(category_frame, text="创建Category")

 ttk.Label(category_frame, text="Category名称:").pack(pady=5)
 category_entry = ttk.Entry(category_frame, width=40)
 category_entry.pack(pady=5)

 def create_category_btn():
 category = category_entry.get().strip()
 if not category:
 messagebox.showerror("错误", "请输入Category名称")
 return
 success, msg = create_category(category)
 messagebox.showinfo("结果", msg)
 # 成功后刷新下拉框
 if success:
 update_category_combobox()

 ttk.Button(category_frame, text="创建Category", command=create_category_btn).pack(pady=10)

 # Tag选项卡
 tag_frame = ttk.Frame(notebook)
 notebook.add(tag_frame, text="创建Tag")

 ttk.Label(tag_frame, text="所属Category:").pack(pady=5)
 tag_category_entry = ttk.Entry(tag_frame, width=40)
 tag_category_entry.pack(pady=5)

 ttk.Label(tag_frame, text="Tag名称:").pack(pady=5)
 tag_entry = ttk.Entry(tag_frame, width=40)
 tag_entry.pack(pady=5)

 def create_tag_btn():
 category = tag_category_entry.get().strip()
 tag = tag_entry.get().strip()
 if not category or not tag:
 messagebox.showerror("错误", "请输入Category和Tag名称")
 return
 success, msg = create_tag(category, tag)
 messagebox.showinfo("结果", msg)
 # 成功后刷新下拉框
 if success:
 update_tag_combobox()

 ttk.Button(tag_frame, text="创建Tag", command=create_tag_btn).pack(pady=10)

 # 文章选项卡
 post_frame = ttk.Frame(notebook)
 notebook.add(post_frame, text="创建文章")

 # Category 下拉框
 ttk.Label(post_frame, text="选择Category（可选）:").pack(pady=5)
 category_combobox = ttk.Combobox(post_frame, width=37, state="readonly")
 category_combobox.pack(pady=5)

 # Tag 下拉框
 ttk.Label(post_frame, text="选择Tag:").pack(pady=5)
 tag_combobox = ttk.Combobox(post_frame, width=37, state="readonly")
 tag_combobox.pack(pady=5)

 ttk.Label(post_frame, text="文章标题:").pack(pady=5)
 post_title_entry = ttk.Entry(post_frame, width=40)
 post_title_entry.pack(pady=5)

 # 更新下拉框内容的函数
 def update_category_combobox():
 categories = get_existing_categories()
 category_combobox["values"] = [""] + categories # 空字符串表示可选
 if categories:
 category_combobox.set("")

 def update_tag_combobox(event=None):
 selected_category = category_combobox.get()
 if selected_category:
 tags = get_existing_tags(selected_category)
 else:
 tags = get_existing_tags()
 tag_combobox["values"] = tags
 if tags:
 tag_combobox.set(tags[0])
 else:
 tag_combobox.set("")

 # 绑定 Category 下拉框的选择事件
 category_combobox.bind("<<ComboboxSelected>>", update_tag_combobox)

 # 初始化下拉框
 update_category_combobox()
 update_tag_combobox()

 def create_post_btn():
 category = category_combobox.get() or None
 tag = tag_combobox.get()
 title = post_title_entry.get().strip()
 if not tag or not title:
 messagebox.showerror("错误", "请选择Tag并输入文章标题")
 return
 success, msg = create_folder_and_md(category, tag, title)
 messagebox.showinfo("结果", msg)

 ttk.Button(post_frame, text="创建文章", command=create_post_btn).pack(pady=10)

 root.mainloop()

def main():
 parser = argparse.ArgumentParser(prog="zata", description="博客目录和文件管理工具")
 subparsers = parser.add_subparsers(dest="command", help="可用命令")

 create_parser = subparsers.add_parser("create", help="创建文章文件夹和index.md")
 create_parser.add_argument("-c", "--categories", help="博客分类（可选）")
 create_parser.add_argument("-t", "--tags", required=True, help="博客标签")
 create_parser.add_argument("-b", "--title", required=True, help="博客标题")

 category_parser = subparsers.add_parser("create-category", help="创建category目录")
 category_parser.add_argument("-c", "--category", required=True, help="要创建的category名称")

 tag_parser = subparsers.add_parser("create-tag", help="创建tag目录")
 tag_parser.add_argument("-c", "--category", required=True, help="所属category")
 tag_parser.add_argument("-t", "--tag", required=True, help="要创建的tag名称")

 gui_parser = subparsers.add_parser("gui", help="启动图形界面")

 args = parser.parse_args()

 if args.command == "create":
 success, msg = create_folder_and_md(args.categories, args.tags, args.title)
 print(msg)
 elif args.command == "create-category":
 success, msg = create_category(args.category)
 print(msg)
 elif args.command == "create-tag":
 success, msg = create_tag(args.category, args.tag)
 print(msg)
 elif args.command == "gui":
 create_gui()
 else:
 parser.print_help()

if __name__ == "__main__":
 main()

一个自动签到的py并且使用github action每日执行

Mon, 03 Mar 2025 14:40:00 +0800

效果就是每天8点去自动签到

使用Cookie进行自动登录（简单，但是很容易因为Cookie过期而需要重新获取Cookie更新）

Cookie的获取

参考： https://www.diuber.com/cookie/

首先需要获取Cookie，这个Cookie是登录之后的Cookie，登录之后的Cookie是在浏览器的开发者工具中获取的，具体方法如下：

打开浏览器，登录mx的账号
打开浏览器的开发者工具，在Network中找到请求的接口，点击请求的接口，在Headers中找到Cookie，复制Cookie

签到的代码

# mx_checkin.py
import requests
import schedule
import time
from datetime import datetime
Cookie = os.environ.get("MX_COOKIE") # 把Cookie放置在action的环境变量中,例如这里是MX_COOKIE
# 签到函数
def checkin():
 # 替换为实际的签到接口 URL
 url = XXXXX

 # 准备请求头（可能需要 Cookie 或 Token 来验证身份）
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/json",
 # 如果需要登录凭证，可以在这里添加 Cookie 或 Authorization
 "Cookie": Cookie,
 # "Authorization": "Bearer your_token_here"
 }

 # 准备请求数据（根据实际接口要求调整）
 data = {
 "userId": "your-user-id", # 替换为你的用户 ID
 "timestamp": int(time.time()) # 可选：发送当前时间戳
 }

 try:
 # 发送签到请求
 response = requests.post(url, headers=headers)
 response_json = response.json()

 # 检查签到是否成功
 if response.status_code == 200 :
 print(f"{datetime.now()} 签到成功：{response_json.get('msg')}")
 else:
 print(f"{datetime.now()} 签到失败：{response_json.get('msg')}")
 except Exception as e:
 print(f"{datetime.now()} 签到请求失败：{str(e)}")


# 脚本主循环
if __name__ == "__main__":
 print("自动签到脚本已启动...")
 # 首次运行时立即签到（可选）
 checkin()

代码写好之后可以先在本地测试，保证测试ok

github action的工作流配置

关于github action的内容，可以查看我的文章 github action使用

# mx_checkin.yml
name: mx_checkin

on:
 schedule:
 # 此处是UTC时间，对应北京时间早八点
 - cron : '00 00 * * *'
 workflow_dispatch:

permissions:
 contents: read

jobs:
 build:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3
 - name: Set up Python 3.12
 uses: actions/setup-python@v3
 with:
 python-version: "3.12"
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 - name: Run checkin script
 run: |
 python mx_checkin.py
 env:
 MX_COOKIE: ${{ secrets.MX_COOKIE }}

requirements.txt

把需要的库写在这个文件中

requests
schedule
datetime

设置仓库密钥

把前面Cookie 填进去 粘贴过来的时候可以把引号去掉，我记得是不用加引号的，如果发现自己电脑上面测试可以，Action不行的话可以再试试加引号

上面的方法很受限于网站对于cookie的验证，如果网站对cookie验证过于严格，可以尝试下面的方法。

使用账号密码进行自动登录（复杂，但是可以避免Cookie过期的问题）

这里我只是给了一个简单的配置，很多网站登录的时候可能会多重验证，那就麻烦了….

找到登录的接口

当然每个网站不一样，不能一概而论

代码

# checkin
import requests
import schedule
import time
from datetime import datetime
import os
import json

from dotenv import load_dotenv
load_dotenv()


def refresh_cookie():
 """刷新 Cookie 的逻辑（需要根据实际网站实现）"""
 global Cookie
 try:
 # 替换为实际的登录 URL 和登录数据
 login_url = "https://mxwljsq.top/auth/login"
 login_data = {
 "email": os.environ.get("MX_EMAIL"), # 从环境变量获取邮箱
 "passwd": os.environ.get("MX_PASSWORD"), # 从环境变量获取密码
 }

 print(login_data)
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/x-www-form-urlencoded"
 }
 # exit()
 # 发送登录请求
 response = requests.post(login_url, data=login_data, headers=headers)
 print(response.text)
 if response.status_code == 200:
 # 假设登录成功后 Cookie 在响应头中返回
 new_cookie = response.cookies.get_dict()
 Cookie = "; ".join([f"{k}={v}" for k, v in new_cookie.items()])
 print(f"{datetime.now()} Cookie 刷新成功")
 return True
 else:
 print(f"{datetime.now()} Cookie 刷新失败：{response.text}")
 return False
 except Exception as e:
 print(f"{datetime.now()} Cookie 刷新异常：{str(e)}")
 return False

def checkin():
 refresh_cookie()
 global Cookie
 if Cookie is None:
 print("Cookie 为空，请先刷新 Cookie")
 return False
 url = "https://mxwljsq.top/user/checkin"
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
 "Content-Type": "application/json",
 "Cookie": Cookie,
 }

 try:
 response = requests.post(url, headers=headers)
 response_json = response.json()

 if response.status_code == 200:
 print(f"{datetime.now()} 签到成功：{response_json.get('msg')}")
 return True
 else:
 print(f"{datetime.now()} 签到失败：{response_json.get('msg')}")
 # 如果是登录失效，尝试刷新 Cookie
 return False
 except Exception as e:
 print(f"{datetime.now()} 签到请求失败：{str(e)}")
 return False

if __name__ == "__main__":
 print("自动签到脚本已启动...")
 # 加载本地 Cookie，如果没有则使用环境变量中的
 # 首次运行立即签到
 print(f"{datetime.now()} 开始执行签到任务...")
 checkin()

# mx_checkin.yml
name: mx_checkin

on:
 schedule:
 # 此处是UTC时间，对应北京时间早八点
 - cron : '00 00 * * *'
 workflow_dispatch:

permissions:
 contents: read

jobs:
 build:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v3
 - name: Set up Python 3.12
 uses: actions/setup-python@v3
 with:
 python-version: "3.12"
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
 - name: Run checkin script
 run: |
 python mx_checkin.py
 env:
 MX_EMAIL: ${{ secrets.MX_EMAIL }}
 MX_PASSWORD: ${{ secrets.MX_PASSWORD }}

设置仓库密钥

这里是肯定不需要加引号的，因为邮箱和密码都是字符串，加引号的话会被认为是字符串。（我试过了）

3-hugo博客集成Netlify CMS

Mon, 03 Mar 2025 00:00:00 +0800

参考：

https://ttys3.dev/blog/setup-netlify-cms-for-hugo [低质量]

https://guanqr.com/tech/website/deploy-blog-to-netlify/

爬虫-基础介绍

Mon, 03 Mar 2025 00:00:00 +0800

介绍

以下是一些常见的 HTTP 状态码（因为它们在网络开发和日常使用中很常见）：

200 OK：请求成功，一切正常。
400 Bad Request：请求有问题，比如参数错误。
401 Unauthorized：未授权，需要登录或提供凭证。
403 Forbidden：服务器拒绝访问，权限不足。
404 Not Found：资源不存在，可能是URL错了。
500 Internal Server Error：服务器内部出错，程序或配置有问题。
503 Service Unavailable：服务暂时不可用，通常是服务器维护或过载。

关键要点

网络爬虫是一种自动浏览网页的程序，主要用于搜索引擎索引，但也用于数据挖掘和网页归档。
它从初始URL开始，下载页面，提取链接，递归访问，形成索引。
挑战包括资源消耗、重复内容和动态内容（如JavaScript页面）。
需遵循选择、重访、礼貌和并行化政策，确保高效和合规。
存在通用、聚焦和深网三种类型，法律和伦理问题需注意，如尊重robots.txt和数据隐私。

定义与目的

网络爬虫，也称为蜘蛛或机器人，是一种系统地浏览万维网以进行网页索引的程序。
它的主要目的是为搜索引擎更新内容或索引，帮助用户更高效地搜索。意外的是，它还用于网页归档、验证超链接和数据挖掘。

工作原理

爬虫从一组已知的URL（种子）开始，下载页面，提取其中的超链接，然后递归访问这些链接，依政策继续扩展。这种过程类似探索迷宫，但需管理大量数据。

示例Python代码

以下是一个简单的Python网络爬虫示例，使用requests和BeautifulSoup库，从给定URL开始，爬取页面上的所有链接并打印：

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

def crawl(url):
 # 发送GET请求到URL
 response = requests.get(url)

 # 检查请求是否成功
 if response.status_code != 200:
 print(f"无法检索 {url}")
 return

 # 解析HTML内容
 soup = BeautifulSoup(response.text, 'html.parser')

 # 查找页面上的所有链接
 for link in soup.find_all('a'):
 # 获取href属性
 href = link.get('href')

 # 如果href为空，跳过此链接
 if href is None:
 continue

 # 将相对URL转换为绝对URL
 absolute_url = urljoin(url, href)

 # 打印绝对URL
 print(absolute_url)

 # 在实际应用中，可以将此URL添加到队列中以供后续爬取
 # 这里仅打印以简化

# 示例用法
start_url = 'https://www.example.com'
crawl(start_url)

此代码提供了一个基本框架，实际应用中需处理重复URL、遵守robots.txt等。

详细报告

网络爬虫是互联网技术的重要组成部分，广泛用于搜索引擎优化（SEO）、数据收集和网站监控。本报告将详细探讨其定义、工作原理、类型、挑战及相关政策，力求全面覆盖用户可能关心的所有方面，并附上Python代码示例。

定义与基本概念

根据Web Crawler - Wikipedia的定义，网络爬虫（也称为蜘蛛、蜘蛛机器人、蚂蚁、自动索引器或Web scutter）是一种系统地浏览万维网以进行网页索引（web spidering）的互联网机器人。
它的核心功能是复制网页内容，供搜索引擎索引，从而提升搜索效率。研究表明，爬虫不仅是搜索引擎的工具，还用于网页归档、验证超链接和HTML代码，以及数据驱动的编程。

工作原理与过程

爬虫的工作流程通常从一组初始URL（称为种子）开始。它会：

下载这些网页，提取其中的超链接。
将新发现的链接添加到爬取前沿（crawl frontier），然后递归访问。
根据预设政策（如选择政策、礼貌政策）决定下载哪些页面及访问频率。

例如，Cloudflare的解释指出，爬虫通过跟随链接“爬行”，类似于人类在网上点击导航，但自动化且规模庞大。
归档方面，爬虫会保存网页快照，存储在类似数据库的仓库中，但功能较数据库简单，通常以HTML文件形式保存。

覆盖范围与局限

互联网的页面数量极其庞大，研究显示（2009年数据），即使是最大的爬虫也只能索引40-70%的可索引网页，而1999年的研究显示仅16%Web Crawler - Wikipedia。
这一局限源于网页数量的爆炸性增长和高变化率，爬虫只能优先处理部分页面。

挑战与问题

爬取过程中面临多重挑战：

资源消耗：爬虫访问系统时会消耗网络和服务器资源，常未经提示访问，引发负载和礼貌性问题。
重复内容：由于HTTP GET参数的无限组合（如在线相册可能有48种不同URL，涉及排序、缩略图大小、格式和用户内容选项），难以避免重复下载Web Crawler - Wikipedia。
动态内容：AJAX页面等动态内容对爬虫构成挑战，Google提出可识别的AJAX调用格式以解决Web Crawler - Wikipedia。

爬取政策

爬取政策是爬虫高效运行的关键，分为以下几类：

选择政策：决定下载哪些页面，常用指标包括广度优先、反向链接计数和部分PageRank。研究（如Cho等，180,000页从stanford.edu爬取）显示，部分PageRank更适合早期捕获高PageRank页面，随后是广度优先和反向链接计数Web Crawler - Wikipedia。
重访政策：目标是最大化新鲜度（本地副本是否准确）或最小化年龄（本地副本多旧）。Cho和Garcia-Molina的研究表明，统一政策（所有页面同频率）优于按变化率比例分配的策略Web Crawler - Wikipedia。
礼貌政策：避免超载服务器，成本包括网络资源、服务器超载和由编写不佳的爬虫导致的崩溃。标准做法是使用robots.txt文件，建议访问间隔从60秒到3-4分钟不等，具体如Cho使用10秒，WIRE爬虫15秒，Mercator用10t秒（t为下载时间），Dill等用1秒Web Crawler - Wikipedia。
并行化政策：运行多个进程以最大化下载率，减少开销，避免重复下载，需政策分配新发现的URL。

以下是各类政策的对比：

政策类型	描述	示例/注意事项
选择政策	决定优先爬取哪些页面	广度优先、PageRank优先
重访政策	确定页面重访频率以保持数据新鲜	统一频率或按变化率调整
礼貌政策	避免超载服务器，遵守robots.txt	建议请求间隔1秒以上
并行化政策	使用多进程提升效率，管理资源分配	避免重复下载，优化爬取速度

类型的网络爬虫

通用爬虫：如Google和Bing的爬虫，目标是索引整个互联网。
聚焦爬虫：尝试下载相关页面，依赖通用搜索引擎作为起点。例如，学术爬虫如citeseerxbot（用于CiteSeer X）关注PDF、PostScript和Word文件，还有Google Scholar和Microsoft Academic SearchWeb Crawler - Wikipedia。
语义聚焦爬虫：使用领域本体进行更精准的爬取。

以下是各类爬虫的对比：

类型	特点	示例
通用爬虫	索引整个互联网，覆盖广	Googlebot, Bingbot
聚焦爬虫	针对特定主题或文件类型，效率高	citeseerxbot, Google Scholar bot
语义聚焦爬虫	使用本体，适合复杂领域	学术研究领域爬虫
企业爬虫	索引企业网站，供内部搜索使用	内部网站搜索引擎

安全与伦理问题

爬虫可能无意中索引非公共资源或暴露软件漏洞版本，缓解方法包括通过robots.txt限制搜索引擎仅索引公共部分，屏蔽交易部分Web Crawler - Wikipedia。
此外，爬虫通过HTTP请求的User-agent字段标识，管理员可通过日志和工具追踪，偏好标识以便在陷入爬虫陷阱或超载服务器时联系。垃圾邮件机器人可能掩盖身份，增加识别难度。

法律和伦理考虑包括：

尊重网站的服务条款和robots.txt文件。
避免以过多请求超载服务器（礼貌政策）。
负责处理个人数据，遵守隐私法。
透明地披露数据收集做法，尤其是涉及个人信息时。

深网爬取

深网（deep web）或不可见网包含大量仅通过数据库查询可访问的页面，常规爬虫需链接才能访问。策略包括：

Google的Sitemaps协议和mod oai。
屏幕抓取（screen scraping）用于跨表单聚合数据。
AJAX页面问题，Google提出可识别的AJAX调用格式Web Crawler - Wikipedia。

可视化与编程化

可视化爬虫/抓取工具降低了编程技能需求，通过高亮数据教学用户使用。例如，Needlebase（被Google作为ITA Labs的一部分收购，Needlebase）是典型代表，简化了数据提取过程Web Crawler - Wikipedia。

总结

网络爬虫是互联网信息获取的核心工具，其效率和伦理问题持续受到关注。未来，随着动态内容和深网的增长，爬虫技术需进一步创新，以平衡覆盖率和资源消耗。

关键引文

2-Hugo主题和配置

Sun, 02 Mar 2025 00:00:00 +0800

参考
https://letere-gzj.github.io/hugo-stack/

可能遇到的问题

如何插入嵌入式视频

B站

直接可以点击分享的嵌入代码然后粘贴到md文件中

<iframe
src="//player.bilibili.com/player.html?isOutside=true&aid=113991737148695&bvid=BV1qQK7eXERw&cid=28358870196&p=1"
scrolling="yes"
border="0"
frameborder="no"
framespacing="0"
allowfullscreen="true">
</iframe>

效果如下：

使用shortcode方式

参考：https://zhuanlan.zhihu.com/p/622866669

创建一个模板文件，内容可以为：

代码：

<div style="position:relative; padding-bottom:75%; width:100%; height:0">

<iframe
 src="//player.bilibili.com/player.html?bvid={{.Get 0 }}&page={{ if .Get 1 }}{{.Get 1}}{{ else }}1{{end}}&as_wide=1&high_quality=1"
 scrolling="no"
 border="0"
 frameborder="no"
 framespacing="0"
 allowfullscreen="true"
 style="position:absolute; height: 100%; width: 100%;"
>
</iframe>
</div>

然后使用下面的语法使用这个模板

效果如下：

< bilibili BV1tXRAYiEYR >

Hugo 文章日期设定上的小问题（时区问题）

参考： https://blog.hly0928.com/post/hugo-post-date-issue/

Hugo 在生成静态页面的时候，不会生成超过当前时间的文章；而 Hugo 默认采用的是格林尼治平时 (GMT)，比北京时间 (UTC+8) 晚了 8 个小时。也就是说，当北京时间在 08:00 之前，而你又将文章发布日期设在当天时，Hugo 就默认不会生成这个页面。

解决方法：最后我选择文章头增加时区信息

---
...
date: 2025-03-02T00:00:00+08:00
...
---

Stack 主题

hugo Stack 配置文件示例

baseurl: www.zata.cc # 定义网站的基础 URL，所有相对链接基于此生成，通常是域名
languageCode: en-us # 指定默认语言代码（如 en-us 表示美国英语）
theme: hugo-theme-stack # 指定使用的 Hugo 主题名称
title: Example Site # 网站的默认标题，显示在浏览器标签页或页面中
copyright: Example Person # 网站版权声明，通常显示在页脚

# Theme i18n support
# Available values: ar, bn, ca, de, el, en, es, fr, hu, id, it, ja, ko, nl, pt-br, th, uk, zh-cn, zh-hk, zh-tw
DefaultContentLanguage: zh-cn # 指定默认内容语言，这里是简体中文（zh-cn）

# Set hasCJKLanguage to true if DefaultContentLanguage is in [zh-cn ja ko]
# This will make .Summary and .WordCount behave correctly for CJK languages.
hasCJKLanguage: false # 是否启用 CJK 语言（中文、日文、韩文）的优化，这里关闭

languages:
 en:
 languageName: English # 语言名称为“英语”
 title: Example Site # 英文版本的网站标题
 weight: 1 # 语言优先级，数字越小优先级越高
 params:
 sidebar:
 subtitle: Example description # 英文侧边栏描述
 zh-cn:
 languageName: 中文 # 语言名称为“中文”
 title: Zata's Blog # 中文版本的网站标题
 weight: 2 # 优先级低于英文
 params:
 sidebar:
 subtitle: # 中文侧边栏描述（此处为空）
 # ar:
 # languageName: عربي # 示例：阿拉伯语名称
 # languagedirection: rtl # 示例：从右到左布局
 # title: موقع تجريبي # 示例：阿拉伯语标题
 # weight: 3 # 示例：优先级
 # params:
 # sidebar:
 # subtitle: وصف تجريبي # 示例：阿拉伯语侧边栏描述

services:
 # Change it to your Disqus shortname before using
 disqus:
 shortname: "hugo-theme-stack" # Disqus 评论系统的短名称，用于启用评论
 # GA Tracking ID
 googleAnalytics:
 id: # Google Analytics 的跟踪 ID（未填写）

pagination:
 pagerSize: 10 # 每页显示的文章数量，这里为 10 篇

permalinks:
 post: /p/:slug/ # 文章链接格式，例如 /p/my-post/
 page: /:slug/ # 普通页面链接格式，例如 /about/

params:
 mainSections:
 - post # 指定主要内容类型为 post（通常是博客文章）
 featuredImageField: image # 指定文章的特色图片字段为 image（文章头的key）
 rssFullContent: true # RSS 订阅输出完整文章内容，而非摘要
 favicon: # 网站图标路径（未设置，例如 /favicon.ico）
 # 网站图标路径#e.g.:favicon placed in static/favicon.ico of your site folder,then set thisfield to/favicon.ico(/is necessay)


 footer:
 since: 2020 # 显示网站起始年份（如“© 2020-2025”）
 customText: # 自定义页脚文本（未设置）

 dateFormat:
 published: Jan 02, 2006 # 文章发布日期格式（例如“Jan 02, 2006”）
 lastUpdated: Jan 02, 2006 15:04 MST # 最后更新时间的格式（包含时区）

 sidebar:
 emoji: 🍥 # 侧边栏显示的表情符号
 subtitle: Hello,I am Zata. # 侧边栏副标题
 avatar:
 enabled: true # 启用头像
 local: true # 头像文件存储在本地
 src: img/avatar.jpg # 头像文件路径

 article:
 math: false # 是否启用数学公式支持（关闭）
 toc: true # 启用文章目录（Table of Contents）
 readingTime: true # 显示阅读时间
 license:
 enabled: false # 是否显示许可声明（关闭）
 default: Licensed under CC BY-NC-SA 4.0 # 默认许可文本

 comments:
 enabled: true # 启用评论
 provider: disqus # 使用 Disqus 作为评论提供者

 disqusjs:
 shortname: # DisqusJS 的短名称（未设置）
 apiUrl: # DisqusJS 的 API 地址（未设置）
 apiKey: # DisqusJS 的 API 密钥（未设置）
 admin: # DisqusJS 管理员（未设置）
 adminLabel: # DisqusJS 管理员标签（未设置）

 utterances:
 repo: # Utterances 的仓库（未设置）
 issueTerm: pathname # Utterances 的问题标识方式（未设置）
 label: # Utterances 的标签（未设置）

 beaudar:
 repo: # Beaudar 的仓库（未设置）
 issueTerm: pathname # Beaudar 的问题标识方式（未设置）
 label: # Beaudar 的标签（未设置）
 theme: # Beaudar 的主题（未设置）

 remark42:
 host: # Remark42 的主机地址（未设置）
 site: # Remark42 的站点名称（未设置）
 locale: # Remark42 的语言（未设置）

 vssue:
 platform: # Vssue 的平台（未设置）
 owner: # Vssue 的拥有者（未设置）
 repo: # Vssue 的仓库（未设置）
 clientId: # Vssue 的客户端 ID（未设置）
 clientSecret: # Vssue 的客户端密钥（未设置）
 autoCreateIssue: false # Vssue 是否自动创建问题（关闭）

 # Waline client configuration see: https://waline.js.org/en/reference/component.html
 waline:
 serverURL: # Waline 的服务器地址（未设置）
 lang: # Waline 的语言（未设置）
 pageview: # Waline 的页面浏览量（未设置）
 emoji:
 - https://unpkg.com/@waline/emojis@1.0.1/weibo # Waline 的表情包地址
 requiredMeta:
 - name # Waline 的必填项：名称
 - email # Waline 的必填项：邮箱
 - url # Waline 的必填项：网址
 locale:
 admin: Admin # Waline 的管理员名称
 placeholder: # Waline 的占位符（未设置）

 twikoo:
 envId: # Twikoo 的环境 ID（未设置）
 region: # Twikoo 的区域（未设置）
 path: # Twikoo 的路径（未设置）
 lang: # Twikoo 的语言（未设置）

 # See https://cactus.chat/docs/reference/web-client/#configuration for description of the various options
 cactus:
 defaultHomeserverUrl: "https://matrix.cactus.chat:8448" # Cactus 的默认服务器地址
 serverName: "cactus.chat" # Cactus 的服务器名称
 siteName: "" # Cactus 的站点名称（需唯一，未设置）

 giscus:
 repo: # Giscus 的仓库（未设置）
 repoID: # Giscus 的仓库 ID（未设置）
 category: # Giscus 的分类（未设置）
 categoryID: # Giscus 的分类 ID（未设置）
 mapping: # Giscus 的映射方式（未设置）
 lightTheme: # Giscus 的亮色主题（未设置）
 darkTheme: # Giscus 的暗色主题（未设置）
 reactionsEnabled: 1 # Giscus 是否启用反应（启用）
 emitMetadata: 0 # Giscus 是否输出元数据（关闭）

 gitalk:
 owner: # Gitalk 的拥有者（未设置）
 admin: # Gitalk 的管理员（未设置）
 repo: # Gitalk 的仓库（未设置）
 clientID: # Gitalk 的客户端 ID（未设置）
 clientSecret: # Gitalk 的客户端密钥（未设置）
 proxy: # Gitalk 的代理（未设置）

 cusdis:
 host: # Cusdis 的主机地址（未设置）
 id: # Cusdis 的 ID（未设置）
 widgets:
 homepage:
 - type: search # 主页小部件：搜索框
 - type: archives # 主页小部件：归档列表
 params:
 limit: 5 # 归档列表限制显示 5 个
 - type: categories # 主页小部件：分类列表
 params:
 limit: 10 # 分类列表限制显示 10 个
 - type: tag-cloud # 主页小部件：标签云
 params:
 limit: 10 # 标签云限制显示 10 个
 page:
 - type: toc # 单页小部件：目录

 opengraph:
 twitter:
 # Your Twitter username
 site: # Twitter 用户名（未设置）
 # Available values: summary, summary_large_image
 card: summary_large_image # Twitter 卡片类型（大图模式）

 defaultImage:
 opengraph:
 enabled: false # 是否启用默认 Open Graph 图片（关闭）
 local: false # 是否使用本地图片（否）
 src: # 图片路径（未设置）

 colorScheme:
 # Display toggle
 toggle: true # 显示主题切换按钮
 # Available values: auto, light, dark
 default: auto # 默认使用自动主题（根据浏览器偏好）

 imageProcessing:
 cover:
 enabled: true # 启用封面图处理
 content:
 enabled: true # 启用内容图片处理

### Custom menu
### See https://stack.jimmycai.com/config/menu
### To remove about, archive and search page menu item, remove `menu` field from their FrontMatter
menu:
 main: [] # 主菜单（为空）
 social:
 - identifier: github # 社交链接：GitHub
 name: GitHub # 显示名称
 url: https://github.com/zata-zhangtao/ZataTree # 链接地址
 params:
 icon: brand-github # 图标名称

 # - identifier: twitter # 示例：Twitter 社交链接（已注释）
 # name: Twitter
 # url: https://twitter.com
 # params:
 # icon: brand-twitter

related:
 includeNewer: true # 相关文章推荐包括较新的文章
 threshold: 60 # 相关性阈值（越高越严格）
 toLower: false # 标签/分类是否忽略大小写
 indices:
 - name: tags # 根据标签匹配相关文章
 weight: 100 # 标签权重
 - name: categories # 根据分类匹配相关文章
 weight: 200 # 分类权重

markup:
 goldmark:
 extensions:
 passthrough:
 enable: true # 启用原始字符渲染（例如数学公式）
 delimiters:
 block:
 - - \[ # 块级数学公式开始分隔符
 - \] # 块级数学公式结束分隔符
 - - $$ # 块级数学公式开始分隔符
 - $$ # 块级数学公式结束分隔符
 inline:
 - - \( # 行内数学公式开始分隔符
 - \) # 行内数学公式结束分隔符
 renderer:
 ## Set to true if you have HTML content inside Markdown
 unsafe: true # 允许在 Markdown 中嵌入 HTML
 tableOfContents:
 endLevel: 4 # 目录包含到 4 级标题
 ordered: true # 目录编号
 startLevel: 2 # 从 2 级标题开始
 highlight:
 noClasses: false # 使用 CSS 类高亮代码
 codeFences: true # 启用代码块
 guessSyntax: true # 自动检测代码语言
 lineNoStart: 1 # 行号从 1 开始
 lineNos: true # 显示行号
 lineNumbersInTable: true # 行号显示在表格中
 tabWidth: 4 # 制表符宽度

frontmatter:
 lastmod: [":fileModTime", "lastmod"] # 定义最后修改时间的来源（文件修改时间或 frontmatter 中的 lastmod）

Hugo Stack 主题添加[最后修改于]

参考：

https://shitao5.org/posts/hugo-stack/

配置[最后修改于]

在主题的.yaml文件中添加
```
frontmatter:
lastmod: [":fileModTime", "lastmod"]
```
这样会显示最后更新于

如果要显示最后修改于 修改 themes/hugo-theme-stack/i18n 文件夹中的 zh-cn.yaml 文件

在文章开头就显示修改时间

参考：
https://letere-gzj.github.io/hugo-stack/p/hugo/custom-stack-theme/#3-%E6%98%BE%E7%A4%BA%E6%96%87%E7%AB%A0%E6%9B%B4%E6%96%B0%E6%97%B6%E9%97%B4

在themes\hugo-theme-satck\layouts\partials\article\components\details.html，在指定位置引入以下代码

 {{- if ne .Lastmod .Date -}}
 <div>
 {{ partial "helper/icon" "clock" }}
 <time class="article-time--published">
 {{ T "article.lastUpdatedOn" }} {{ .Lastmod | time.Format ( or .Site.Params.dateFormat.lastUpdated "Jan 02, 2006 15:04 MST" ) }}
 </time>
 </div>
 {{- end -}}

在主题的.yaml文件中添加

# 更新时间：优先读取git时间 -> git时间不存在，就读取本地文件修改时间
frontmatter:
 lastmod:
 - :git
 - :fileModTime

# 允许获取Git信息 
enableGitInfo: true

这部分指定了Hugo获取lastmod值的优先级顺序：
:git：优先使用Git提交历史中的最后修改时间（更准确反映内容实际更新时间）。
:fileModTime：如果Git信息不可用，则使用本地文件的修改时间作为备选。
如果不设置这个，Hugo可能无法正确填充.Lastmod，导致你的代码 {{ if ne .Lastmod .Date }} 条件永远不生效。
enableGitInfo: true：
默认情况下，Hugo不会去查询Git信息（为了性能考虑）。
设置 enableGitInfo: true 后，Hugo会利用Git仓库的提交历史来填充页面变量（如 .Lastmod）。
如果你使用的是版本控制（比如GitHub），这个设置非常有用，因为它能确保修改时间反映的是内容的实际提交时间，而不是本地文件的时间（后者可能因环境不同而变化）。

修改github action文件.github/workflows/xxx.yaml，让可以读取git信息

- name: Git Configuration
run: |
 git config --global core.quotePath false
 git config --global core.autocrlf false
 git config --global core.safecrlf true
 git config --global core.ignorecase false

这些配置确保Git在构建过程中能够正确处理文件路径和换行符等问题，避免因环境差异导致的异常。
core.quotePath false：确保特殊字符的文件名不会被转义。
core.autocrlf false：避免换行符转换问题（不同系统可能处理不同）。
core.safecrlf true：确保换行符处理安全。
core.ignorecase false：保持文件名大小写敏感。
这些设置虽然不直接决定.Lastmod，但能确保Git仓库的行为一致，避免潜在问题。

代码块过长折叠&展开

准备一张图片作为代码展开的按钮，放到assets/icons文件夹下，并命名为codeMore.png
将下面代码复制粘贴到layouts/partials/footer/custom.html中(文件没有就新建)，有报错不要管

<style>
 .highlight {
 /* 你可以根据需要调整这个高度 */
 max-height: 400px;
 overflow: hidden;
 }

 .code-show {
 max-height: none !important;
 }

 .code-more-box {
 width: 100%;
 padding-top: 78px;
 background-image: -webkit-gradient(linear, left top, left bottom, from(rgba(255, 255, 255, 0)), to(#fff));
 position: absolute;
 left: 0;
 right: 0;
 bottom: 0;
 z-index: 1;
 }

 .code-more-btn {
 display: block;
 margin: auto;
 width: 44px;
 height: 22px;
 background: #f0f0f5;
 border-top-left-radius: 8px;
 border-top-right-radius: 8px;
 padding-top: 6px;
 cursor: pointer;
 }

 .code-more-img {
 cursor: pointer !important;
 display: block;
 margin: auto;
 width: 22px;
 height: 16px;
 }
</style>

<script>
 function initCodeMoreBox() {
 let codeBlocks = document.querySelectorAll(".highlight");
 if (!codeBlocks) {
 return;
 }
 codeBlocks.forEach(codeBlock => {
 // 校验是否overflow
 if (codeBlock.scrollHeight <= codeBlock.clientHeight) {
 return;
 }
 // 元素初始化
 // codeMoreBox
 let codeMoreBox = document.createElement('div');
 codeMoreBox.classList.add('code-more-box');
 // codeMoreBtn
 let codeMoreBtn = document.createElement('span');
 codeMoreBtn.classList.add('code-more-btn');
 codeMoreBtn.addEventListener('click', () => {
 codeBlock.classList.add('code-show');
 codeMoreBox.style.display = 'none';
 // 触发resize事件，重新计算目录位置
 window.dispatchEvent(new Event('resize'))
 })
 // img
 let img = document.createElement('img');
 img.classList.add('code-more-img');
 img.src = {{ (resources.Get "icons/codemore.png").Permalink }}
 // 元素添加
 codeMoreBtn.appendChild(img);
 codeMoreBox.appendChild(codeMoreBtn);
 codeBlock.appendChild(codeMoreBox)
 })
 }

 initCodeMoreBox();
</script>

添加’返回顶部’按钮

图片还是和代码块过长一样放在/assets/icons文件夹下，命名为backtop.png
修改layouts/partials/footer/custom.html文件，下面的代码是直接在代码块折叠的基础上又加了返回最顶按钮.粘贴代码一样也是，vscode报错也别理

<style>
 .highlight {
 max-height: 400px;
 overflow: hidden;
 position: relative;
 }

 .code-show {
 max-height: none !important;
 }

 .code-more-box {
 width: 100%;
 padding-top: 78px;
 background-image: linear-gradient(to bottom, rgba(255, 255, 255, 0), #fff);
 position: absolute;
 left: 0;
 bottom: 0;
 z-index: 1;
 }

 .code-more-btn {
 display: block;
 margin: 0 auto;
 width: 44px;
 height: 22px;
 background: #f0f0f5;
 border-top-left-radius: 8px;
 border-top-right-radius: 8px;
 padding-top: 6px;
 cursor: pointer;
 }

 .code-more-img {
 display: block;
 margin: 0 auto;
 width: 22px;
 height: 16px;
 }

 #backTopBtn {
 display: none;
 position: fixed;
 bottom: 30px;
 right: 20px;
 z-index: 99;
 cursor: pointer;
 width: 30px;
 height: 30px;
 background-image: url({{ (resources.Get "icons/backtop.png").RelPermalink }});
 background-size: cover;
 background-repeat: no-repeat;
 }
</style>

<script>
 function initCodeMoreBox() {
 try {
 const codeBlocks = document.querySelectorAll(".highlight");
 if (!codeBlocks.length) return;

 codeBlocks.forEach(codeBlock => {
 if (codeBlock.scrollHeight <= codeBlock.clientHeight) return;

 const codeMoreBox = document.createElement('div');
 codeMoreBox.classList.add('code-more-box');

 const codeMoreBtn = document.createElement('span');
 codeMoreBtn.classList.add('code-more-btn');

 const img = document.createElement('img');
 img.classList.add('code-more-img');
 img.src = "{{ (resources.Get "icons/codemore.png").RelPermalink }}";
 img.alt = 'Show more';

 codeMoreBtn.addEventListener('click', () => {
 codeBlock.classList.add('code-show');
 codeMoreBox.style.display = 'none';
 window.dispatchEvent(new Event('resize'));
 });

 codeMoreBtn.appendChild(img);
 codeMoreBox.appendChild(codeMoreBtn);
 codeBlock.appendChild(codeMoreBox);
 });
 } catch (error) {
 console.error('Error in initCodeMoreBox:', error);
 }
 }

 function initScrollTop() {
 try {
 const rightSideBar = document.querySelector(".right-sidebar");
 if (!rightSideBar) {
 console.warn('Right sidebar not found');
 return;
 }

 const btn = document.createElement("div");
 btn.id = "backTopBtn";
 btn.onclick = backToTop;
 rightSideBar.appendChild(btn);

 window.onscroll = function () {
 if (document.body.scrollTop > 20 || document.documentElement.scrollTop > 20) {
 btn.style.display = "block";
 } else {
 btn.style.display = "none";
 }
 };
 } catch (error) {
 console.error('Error in initScrollTop:', error);
 }
 }

 function backToTop() {
 window.scrollTo({ top: 0, behavior: "smooth" });
 }

 document.addEventListener('DOMContentLoaded', () => {
 initCodeMoreBox();
 initScrollTop();
 });
</script>

如何修改导航栏

修改content文件夹中的page文件夹下的文件夹，每一个文件夹代表一个导航栏

文件夹中的md文件就是页面

这里有一个奇怪的页面archives

看到源码，实际上主要是layout这个属性

这个layout属性对应的就是一个html页面，在主题中定义

archives页面中，卡片对应的图片在哪里

这些图片对应的也是页面，在content根目录下面创建两个文件夹，分别是categories和tags就可以了

其他主题（还没使用的

Book

后续： 2025-05-08

我去试了一些，直接修改主题并没有它示例上面的功能，但是想要改配置的话也没有教程可以参考，所以放弃

Lovelt

1-hugo安装使用

Fri, 28 Feb 2025 00:00:00 +0000

hugo

常用命令

# start the hugo server
hugo server -D

# build the hugo site
hugo -D

hugo使用注意事项

文件命名必须是index.xxxx.md

md文件+图片的组合，文件夹的名称是随意命名的，但文件夹里md文件的命名，必须为index.md或index.zh-cn.md否则图片资源可能在打包上传时会消失。

图片资源的放置位置有讲究 看下面两张图，三张图片在md文件中本地查看都是可以的，但是在打包上传时，最后一个图片资源可能会消失。

图片资源必须和.md文件在同一个文件夹下，否则图片资源可能在打包上传时会消失。

hugo在ubuntu系统下安装使用

2025年5月5日，本来想要在服务器上部署到，试了没成功，感觉挺难的，最后把服务器改成了windows系统 2025年7月14日，我在mac到容器中执行apt install hugo 很容易就安装上了啊

https://gohugo.io/getting-started/quick-start/

安装hugo

sudo apt install hugo

安装git

sudo apt install git-all

hugo在windwos安装使用

download 下载

https://github.com/gohugoio/hugo/releases

unzip to local 解压到本地 , example : here I created a folder

run the cmd command under the directory 在目录下面运行cmd命令 ,example : here I created a folder named zata

hugo new site zata

copy hugo.exe to zata folder 把hugo.exe复制到zata文件夹
run the cmd command under the directory 在目录下面运行cmd命令,example : here I created a folder named zata
then you can see the example site
next step, you need to install the theme
choose the theme you want to install , example : here I choose the theme named Stack
unzip the theme to the zata/themes folder, and delete the version number
copy [your-theme-name]/exampleSite/config.toml&content to zata/
delete the toml file, because the toml file is not used, the yaml file is used
delete rich-content folder,because the rich-content folder is cite some website, and the website is not used
run the cmd command under the directory in zata folder, then you can see:
then you can create a new post

hugo new content post/myFristBlog/index.md

myFtistBlog is the name of the page In hugo, a folder is a page, then the default language of index.md that you can modify in the hugo.yaml, the default language of index.zh-cn.md is Chinese, and the images used in md will be placed in this folder.

使用github部署hugo的静态页面常规方式（下面一节使用github action）

将hugo的编译成静态页面

修改配置文件中的baseurl,具体如何修改可以看下一节 :如何对应github静态页面的域名

在根目录下面使用hugo -D 命令生成静态页面 using “hugo -D” command to generate static pages in the root directory
```
hugo -D
```

这将生成一个public文件夹 This will generate a public folder

push 上一步生成的pulic文件夹到github

首先需要在github上创建一个仓库，这个仓库名如果是"[你的用户名].github.io" 那么后续生成的静态页面的地址就不会有后缀，不然就会有后缀，例如我的github名字是zata-zhangtao,我创建了一个仓库为zata-zhangtao.github.io，那么生成的静态页面的地址就是zata-zhangtao.github.io，而如果仓库名为zata-zhangtao, 那么生成的静态页面地址就会是zata-zhangtao.github.io/zata-zhangtao/

First, you need to create a repository on github, and if the repository name is “[your-username].github.io”, then the static pages will not have a suffix, otherwise there will be a suffix, for example, my github username is zata-zhangtao, I created a repository named zata-zhangtao.github.io, then the static pages address will be zata-zhangtao.github.io, but if the repository name iszata-zhangtao, then the static pages address will be z

把刚刚的public文件夹push到github上

push the public folder to github

具体的push命令和方式不在具体说明

the specific push command and way are not detailed

设置github静态页面 setting up github pages

进入仓库的设置页面，然后点击pages,然后再选你那个分支作为你的静态页面，选择完成之后，稍等几分钟，看到页面产生就可以使用了 into the repository settings page, click pages, then choose your branch as your static page, select complete, wait a few minutes, and see if the page is generated, and you can use it

如果你前面配置文件中的baseurl没有配置正确，可能会出现点击域名之后发现页面有问题，解决： 重新修改baseurl，并重新编译和push，并且注意编译的时候有没有报错 if the baseurl in the hogo.yaml is not configured correctly, you will find that the page is not displayed correctly after clicking the domain, solve it by modifying the baseurl, recompiling and pushing, and pay attention to whether there are any errors when compiling

然后你就可以看见你的静态页面了 then you can see your static page

github 自动部署hugo的静态页面

automatically deploy hugo’s static page by github action

参考网址：

https://www.bilibili.com/video/BV1bovfeaEtQ?p=4
https://gohugo.io/hosting-and-deployment/hosting-on-github/#build-hugo-with-github-action

“GitHub 自动部署 Hugo 的静态页面”是指利用 GitHub Actions（GitHub 提供的工作流自动化工具）来实现以下过程：当你推送 Hugo 项目代码到 GitHub 仓库时，自动完成 Hugo 静态网站的构建并将其部署到某个目标位置（通常是 GitHub Pages），无需手动操作。

在自己的根路径下面创建一个.github/workflows/hugo.yaml文件,并将如下代码复制粘贴进去 配置文件中有几点值得注意：

需要修改你的分支名，我这里是hugo,需要改成你自己的分支名

注意一下版本的问题，这里我默认版本是0.141.0，

# Sample workflow for building and deploying a Hugo site to GitHub Pages
name: Deploy Hugo site to Pages

on:
 # Runs on pushes targeting the default branch
 push:
 branches:
 - hugo  # 注意要要修改你的分支名

 # Allows you to run this workflow manually from the Actions tab
 workflow_dispatch:

# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
permissions:
 contents: read
 pages: write
 id-token: write

# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
concurrency:
 group: "pages"
 cancel-in-progress: false

# Default to bash
defaults:
 run:
 shell: bash

jobs:
 # Build job
 build:
 runs-on: ubuntu-latest
 env:
 HUGO_VERSION: 0.141.0
 steps:
 - name: Install Hugo CLI
 run: |
 wget -O ${{ runner.temp }}/hugo.deb https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_extended_${HUGO_VERSION}_linux-amd64.deb \
 && sudo dpkg -i ${{ runner.temp }}/hugo.deb
 - name: Install Dart Sass
 run: sudo snap install dart-sass
 - name: Checkout
 uses: actions/checkout@v4
 with:
 submodules: recursive
 fetch-depth: 0
 - name: Setup Pages
 id: pages
 uses: actions/configure-pages@v5
 - name: Install Node.js dependencies
 run: "[[ -f package-lock.json || -f npm-shrinkwrap.json ]] && npm ci || true"
 - name: Build with Hugo
 env:
 HUGO_CACHEDIR: ${{ runner.temp }}/hugo_cache
 HUGO_ENVIRONMENT: production
 TZ: America/Los_Angeles
 run: |
 hugo \
 --gc \
 --minify \
 --baseURL "${{ steps.pages.outputs.base_url }}/"
 - name: Upload artifact
 uses: actions/upload-pages-artifact@v3
 with:
 path: ./public

 # Deployment job
 deploy:
 environment:
 name: github-pages
 url: ${{ steps.deployment.outputs.page_url }}
 runs-on: ubuntu-latest
 needs: build
 steps:
 - name: Deploy to GitHub Pages
 id: deployment
 uses: actions/deploy-pages@v4

创建一个github仓库，然后进入setting，将build and development 改成Github Action ，并且修改环境变量 ctreate a github repository, then enter setting, change build and development to Github Action, and modify the environment variable

修改Github Action

修改环境变量
需要将自己的根目录上传到github的一个仓库中，push之前可以把public文件夹和resources文件夹忽略掉,因为这两个文件夹是hugo编译生成的,自动部署可以自己生成，就不需要了。同时你许要修改根路径下面的yaml文件，主要是其中的baseurl，修改为https://<username>.github.io/<repository> 当然如果你的仓库名是<username>.github.io就可以修改为https://<username>.github.io you need to upload your root directory to a github repository, the repository name is not important, you can ignore the public folder and resources folder before pushing,because these two folders are generated by hugo, you don’t need them. Also you need to modify the yaml file in the root directory, mainly the baseurl, modify it to https://<username>.github.io/<repository>, of course if your repository name is <username>.github.io you can modify it to https://<username>.github.io
准备好之后就可以push了，注意别push错了，必须要是之前配置环境变量和workflows里面的分支,push之后可以到action里面查看进度，稍后就可访问静态页面了 You are ready to push, don’t push wrong, you must push to the branch you configured in the environment variable and workflows,push it, you can see the progress in the action, and you can access the static page later

怎么使用自己的域名访问github pages

配置DNS 登录你自己的域名服务商,我的域名服务商是阿里云，这里配置两条记录,无论你原本是不是访问需要加分支名或者什么，解析地址都是<username>.github.io
到github仓库当中，修改如下配置：setting->Pages->Custom domain->输入你的域名->保存注意如果允许勾选enforce HTTPS，就一定勾选它，这会让你访问的时候浏览器显示安全

配置相关

配置页面的样式可以在项目的根目录下的config.yaml文件中进行配置。
默认index.md文件头

---
title: Chinese Test
description: 这是一个副标题
date: 2020-09-09
slug: test-chinese
image: helena-hertz-wWZzXlDpMog-unsplash.jpg
categories:
 - Test
 - 测试
---

内容解释

在 Hugo（一个流行的静态网站生成器）中，“slug” 是一个用于控制页面 URL 的重要概念。它通常在文件的**前端事项（front matter）**中定义，用于自定义页面或文章的 URL 路径的最后一段。以下是关于 Hugo 中 “slug” 的详细解释：

什么是 slug？

定义：Slug 是一个简洁、URL 友好的字符串，通常由小写字母、数字和连字符（-）组成，用于标识页面或内容的 URL。
作用：它替代了默认的文件名或标题生成的 URL 片段，让 URL 更简洁、可读，并且对搜索引擎优化（SEO）更友好。
默认行为：如果没有在前端事项中定义 slug，Hugo 会使用文件名（去掉扩展名）或标题（经过处理，如空格转为连字符）来生成 URL 的最后一段。

在 Hugo 中使用 slug 你可以在 Markdown 文件的前端事项中手动设置 slug。例如：

---
title: "我的第一篇文章"
slug: "my-first-post"
---

效果：假设文件位于 content/posts/ 目录下，默认情况下，URL 可能是 /posts/我的第一篇文章/（或根据配置转为拼音/其他形式）。设置了 slug: "my-first-post" 后，URL 会变成 /posts/my-first-post/。
适用范围：Slug 只影响 URL 的最后一段（文件名部分），不会改变目录结构（即 posts 部分仍由文件路径决定）。

slug vs 文件名

如果不设置 slug，Hugo 默认使用文件名。例如，文件名为 my-first-post.md，URL 会是 /posts/my-first-post/。
设置 slug 后，它会覆盖文件名。例如：
- 文件名：article-001.md
- 前端事项：slug: "new-article"
- 结果 URL：/posts/new-article/

slug 的规则和注意事项

字符限制：建议使用小写字母、数字和连字符，避免空格、特殊字符或大写字母，以符合 URL 标准。
与 url 的区别：Hugo 中还有一个 url 前端事项选项，它可以完全覆盖整个路径（包括目录部分），而 slug 只修改最后一段。例如：
```
---
slug: "my-post"
url: "/custom/path/to/my-post/"
---
```
- slug 只影响 /my-post 部分。
- url 会覆盖整个路径为 /custom/path/to/my-post/。

多语言支持：在多语言网站中，可以为每种语言设置不同的 slug。例如：

# content/post/my-post.en.md
---
slug: "my-post"
---
# content/post/my-post.fr.md
---
slug: "mon-article"
---

Dify

Fri, 28 Feb 2025 00:00:00 +0000

Dify

简介

Dify 是一款开源的大语言模型（LLM）应用开发平台，融合了后端即服务（Backend as Service）和 LLMOps 的理念，使开发者可以快速搭建生产级的生成式 AI 应用。它支持 GPT 系列模型以及其他大语言模型，专为用户提供便捷的人工智能应用程序开发体验。

示例

在 Dify 中，示例输出通常用于为 AI Agent 提供书写格式的参考，以确保其输出更接近预期。例如，在搭建个人在线旅游助手时，可以通过示例输出定义期望的回答格式和内容。

优缺点

优点：

全面的 UI：Dify 提供了直观的用户界面，简化了开发过程。
内置工具与 API 支持：将许多热门工具和第三方 API 接口内置在系统组件中，对初级用户非常友好。
模块化设计：具有成熟的技术栈，易于扩展和二次开发。

缺点：

相较于 LangChain 等工具，Dify 在灵活性和深度定制性方面可能稍显不足。

应用场景

Dify 可广泛应用于多种场景，包括但不限于：

构建 AI 问答助手，快速响应用户问题。
开发个人在线旅游助手，提供定制化的旅行建议。
创建基于知识库的智能客服系统，提升企业服务效率。

演示视频和参考

虽然目前没有直接提到 Dify 的具体演示视频链接，但可以通过以下资源进一步了解其功能和使用方法：

Dify 学习笔记系列提供了详细的入门教程和实际案例。
bilibiliCoze与Dify知识库问答对比分享了关于工作流和节点使用的经验。

软件自动更新

Fri, 28 Feb 2025 00:00:00 +0000

软件自动更新

TODO

把服务器部署功能写成docker file的形式【2025-02-26】
把客户端的封装成一个exe 【2025-02-26】
把上传更新文件写成用一个页面上传【2025-02-26】
当前的更新和上传方式都是把全部的文件都上传和下载，文件一大太慢了，需要优化一下，只上传更新的文件【2025-02-26】

软件自动更新的重要性

当软件开发过程中出现一些小bug，可以通过热补丁的方式快速修复（热补丁比较难，暂时没学）
如果软件版本升级，不用总是去重新下载安装包。
从用户体验角度来说，软件能自动更新也是更方便使用的。

软件自动更新方面我找到的一些参考

https://blog.csdn.net/danxuezx/article/details/83784318 https://www.cnblogs.com/lindexi/p/18426258 【五颗星，很值得看】 https://www.chromium.org/developers/design-documents/software-updates-courgette/ 【谷歌的压缩编译压缩方法】 https://github.com/wayne-1024/auto-upgrade 【一个自动更新的代码仓库，就是比较旧了】 https://github.com/vslavik/winsparkle?tab=readme-ov-file 【winsparkle 一个用于自动更新的框架】 https://zhuanlan.zhihu.com/p/425845057 【动态更新的知识，大佬】 https://fugary.com/?p=523 【比较详细的教程】 https://www.cnblogs.com/CSSZBB/p/12882068.html 【这个人自己写了一个发布更新程序，部署在他自己服务器，可供别人使用】

我自己写了一个自动更新的代码，基于python 的

主要分为（用于提供更新服务的后端，有更新就下载文件进行更新的前端）

首先需要在服务器端部署一个服务，这个服务主要用于两个功能，第一个功能就是你把新的版本上传给他，第二个功能就是，你的客户端每次启动的时候来访问一下这个服务，看看有没有更新可以用，如果有更新那么就下载更新，提供下载的功能
前端也就是客户端，每次启动的时候都去检查一下，如果有更新了就下载更新，然后根据配置文件去本地找文件进行更新

服务器端

首先需要在服务器上面安装python环境，然后运行下面的代码（建议新建一个文件夹）

flask 需要建议在后台运行，可以使用tmux

安装tmux

apt-get update
apt-get install tmux

tmux new -s [会话名] # 新建会话

tmux a -t [会话名] # 进入会话

ctrl + b + d # 退出会话

tmux kill-session -t 【会话名或编号】 # 杀死会话

安装conda


wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh
cd ~
source .bashrc

创建虚拟环境

conda create -n myenv python=3.10
conda activate myenv

安装flask

pip install flask

flask程序

# app.py
from flask import Flask, jsonify, send_file, request
import os
import json
import hashlib
from werkzeug.utils import secure_filename

app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 1600 * 1024 * 1024 # 配置最大可上传的文件大小为1600MB


# 配置文件存储路径
UPLOAD_FOLDER = 'updates'
CONFIG_FILE = 'update_config.json'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

def ensure_upload_folder():
 """确保上传文件夹存在"""
 if not os.path.exists(UPLOAD_FOLDER):
 os.makedirs(UPLOAD_FOLDER)

def calculate_file_hash(file_path):
 """计算文件MD5哈希值"""
 hash_md5 = hashlib.md5()
 with open(file_path, "rb") as f:
 for chunk in iter(lambda: f.read(4096), b""):
 hash_md5.update(chunk)
 return hash_md5.hexdigest()

def update_config(version, notes, filename):
 """更新配置文件"""
 config = {
 "version": version,
 "publish_notes": notes,
 "download_url": f"/download/{filename}",
 "file_hash": calculate_file_hash(os.path.join(app.config['UPLOAD_FOLDER'], filename)),
 "keep_old_files": ["data.txt"] # 可以根据需要修改
 }

 with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
 json.dump(config, f, ensure_ascii=False, indent=4)

@app.route('/')
def hello():
 return "Hello, Flask with Nginx!"

@app.route('/update_config')
def get_update_config():
 """获取更新配置"""
 try:
 with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
 return jsonify(json.load(f))
 except FileNotFoundError:
 return jsonify({"error": "Configuration file not found"}), 404

@app.route('/download/<filename>')
def download_file(filename):
 """下载更新文件"""
 try:
 return send_file(
 os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(filename)),
 as_attachment=True
 )
 except FileNotFoundError:
 return jsonify({"error": "File not found"}), 404

@app.route('/upload', methods=['POST'])
def upload_file():
 """上传新版本"""
 if 'file' not in request.files:
 return jsonify({"error": "No file part"}), 400

 file = request.files['file']
 version = request.form.get('version')
 notes = request.form.get('notes')

 if file.filename == '':
 return jsonify({"error": "No selected file"}), 400

 if file:
 ensure_upload_folder()
 filename = secure_filename(file.filename)
 file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
 file.save(file_path)
 update_config(version, notes, filename)
 return jsonify({"message": "Upload successful"}), 200

if __name__ == '__main__':
 app.run(host='0.0.0.0', port=5000)

# requirements.txt
"""
Flask==3.0.0
gunicorn==21.2.0
Werkzeug==3.0.0
"""

在tmux 里面，使用 python app.py 运行起来，然后分离会话

如果这一步没有问题的话，使用浏览器访问【域名:5000】，如果能访问到，说明后端程序已经配置成功了

nginx 配置

上面光配置了flask的后端程序是不行，这样直接访问域名/ip是找不到的，还需要配置nginx做一个代理，让nginx去访问flask的后端程序

首先你需要安装nginx,可以按照下面的步骤进行安装,注意，安装就可以了，不要启动nginx！！！

# Ubuntu官方列表的Nginx版本不一定是最新的。所以请添加Nginx安装列表：
# 这一步不是必须的，但建议执行，不然安装的Nginx版本会挺旧的。
$ sudo apt install software-properties-common
$ sudo add-apt-repository ppa:nginx/stable

# 更新列表
$ sudo apt-get update

# 安装 Nginx
$ sudo apt-get install nginx

$ nginx -v # 查看Nginx版本号
$ dpkg -L nginx # 查看Nginx安装位置，输出/usr/share/doc/nginx。其他文件在/etc/nginx
$ dpkg --list # 查看已安装的包

$ sudo apt-get remove nginx nginx-common # 删除Nginx（保留配置文件)
$ sudo apt-get purge nginx nginx-common # 删除Nginx（且不保留配置文件)
$ sudo apt-get autoremove # 删除依赖（dependencies）

$ service nginx status # 查看Nginx状态，默认在运行ing
# 此时访问服务器的IP地址即可看到"Welcome to nginx!"的页面

# 每次更新 Nginx 配置后，都建议重启一下 Nginx
$ service nginx start # Nginx启动命令
$ service nginx stop # Nginx停止命令
$ service nginx restart # Nginx重启命令

nginx配置

进入到配置文件中

vim /etc/nginx/sites-available/update-server

修改以下代码

server {
 listen 80; # 也就是其他地方访问需要的端口，nginx默认是80，也就是不需要额外加端口可以访问,记得把防火墙打开，还要就是没有被其他程序占用，
 server_name zata.cc; # 自己的域名或者ip地址

 location / {
 proxy_pass http://127.0.0.1:5000; # 需要代理的地址
 proxy_set_header Host $host;
 proxy_set_header X-Real-IP $remote_addr;
 proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 }
}

然后创建符号链接让配置生效

# 创建符号链接
sudo ln -s /etc/nginx/sites-available/update-server /etc/nginx/sites-enabled/

查看符号链接是否创建成功

ls -l /etc/nginx/sites-enabled/

查看配置是否有问题

sudo nginx -t

启动nginx

cd /etc/nginx
servce nginx start

再检查一下是否有问题

sudo nginx -t

然后直接访问域名或者ip

可以看到不加端口也可以访问了到这一步说明flask和nginx都配成功了，不过如果遇到：

<html>
<head><title>413 Request Entity Too Large</title></head>
<body>
<center><h1>413 Request Entity Too Large</h1></center>
<hr><center>nginx/1.18.0 (Ubuntu)</center>
</body>
</html>

这个是由于nginx也有上传文件大小的要求，可以修改nginx的配置文件

上传前需要准备代码文件和用于更新的配置文件首先是代码文件，这个需要打包成.zip文件，然后解压之后就相当于安装目录下面的所有文件

就比如这个文件夹，remote.zip里面的文件就是所有其他文件打包的

然后是配置文件，这个文件是用来记录当前版本的信息，以及更新的信息,这个本地和远程都需要放，本地版本的配置文件里面的版本只有小于远程版本才会更新的

测试时候上传服务器可以把版本调大一点

// conf.json


{
 "keep_files": [
 "data.txt",
 "updater.py"
 ],
 "version": "1.0.0",
 "publish_notes": "初始版本"

}

keep_files 是需要保留的文件，这些文件或者是文件夹不会倍更新 version 是当前版本的信息

publish_notes 是更新的信息

然后把这两个文件都上传到服务器上，然后就可以使用了

上传文件

这里就使用windows的命令行进行上传，当然也可以使用其他方式

curl -X POST -F "zip_file=@remote.zip" -F "config=@conf.json" [your IP or domain]/upload

这里上传之后就看客户端了

客户端

首先把这个程序放在客户端的安装目录下面（注意修改你的ip或者域名）

python文件打包成exe （单文件，无控制台）

pyinstaller -F -w updater.py

客户端的程序

客户端更新程序

# # updater.py
# # updater.py
import json
import hashlib
import os
import shutil
import requests
from pathlib import Path
import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--host', default="XXX.XXX.XXX.XXX", help="服务器IP地址或域名")
args = parser.parse_args()
YOUR_HOST = args.host

class AutoUpdater:
 def __init__(self, config_path=f"http://{YOUR_HOST}/update_config"):
 self.config_path = config_path
 self.config = None
 with open('update.json', 'r', encoding='utf-8') as f:
 self.current_version = json.load(f)['version']

 def load_config(self):
 """加载更新配置文件"""
 try:
 # 远程配置文件
 response = requests.get(self.config_path)
 self.config = response.json()
 return True
 except Exception as e:
 print(f"加载配置文件失败: {str(e)}")
 return False

 def check_update(self):
 """检查是否需要更新"""
 if not self.config:
 return False

 return self.config['version'] != self.current_version

 def calculate_file_hash(self, file_path):
 """计算文件的MD5哈希值"""
 hash_md5 = hashlib.md5()
 with open(file_path, "rb") as f:
 for chunk in iter(lambda: f.read(4096), b""):
 hash_md5.update(chunk)
 return hash_md5.hexdigest()

 def download_update(self, temp_dir="temp_update"):
 """下载更新文件"""
 if not os.path.exists(temp_dir):
 os.makedirs(temp_dir)

 try:
 # 下载更新文件
 update_file = f"{temp_dir}/update.zip"
 download_route = self.config["download_url"]


 response = requests.get(f'http://{YOUR_HOST}{download_route}', stream=True)
 with open(update_file, 'wb') as f:
 for chunk in response.iter_content(chunk_size=8192):
 f.write(chunk)

 # 验证文件哈希
 if self.calculate_file_hash(update_file) != self.config['file_hash']:
 print("文件验证失败！")
 return False

 return update_file
 except Exception as e:
 print(f"下载更新失败: {str(e)}")
 return False

 def backup_files(self, backup_dir="backup"):
 """备份当前文件"""
 try:
 if not os.path.exists(backup_dir):
 os.makedirs(backup_dir)

 # 备份当前目录下的所有文件
 for item in os.listdir('.'):
 if item not in [backup_dir, 'temp_update', 'updater.exe','launcher.exe']:
 src = os.path.join('.', item)
 dst = os.path.join(backup_dir, item)
 if os.path.isfile(src):
 shutil.copy2(src, dst)
 elif os.path.isdir(src):
 shutil.copytree(src, dst)
 return True
 except Exception as e:
 print(f"备份文件失败: {str(e)}")
 return False

 def apply_update(self, update_file, temp_dir="temp_update"):
 """应用更新"""
 try:
 # 解压更新文件
 shutil.unpack_archive(update_file, temp_dir)

 # 保留指定的旧文件和文件夹
 keep_files = self.config.get('keep_files', [])
 for file in keep_files:
 if os.path.exists(file):
 # 如果文件在子文件夹中,需要创建对应的临时文件夹
 temp_path = os.path.join(temp_dir, f"{file}")
 temp_dir_path = os.path.dirname(temp_path)
 if temp_dir_path and not os.path.exists(temp_dir_path):
 os.makedirs(temp_dir_path)
 print(f"备份: {file} -> {temp_path}")
 if os.path.isfile(file):
 shutil.copy2(file, temp_path)
 elif os.path.isdir(file):
 # 如果是文件夹则整个复制
 shutil.copytree(file, temp_path)

 need_restart = False
 # 修改删除文件的部分，添加重试和错误处理
 for item in os.listdir('.'):
 if item not in ['backup', 'temp_update', 'updater.exe','launcher.exe']:
 path = os.path.join('.', item)

 try:
 if os.path.isfile(path):
 try:
 os.remove(path)
 except PermissionError:
 print(f"警告: 文件 {path} 正在使用中，将在重启后更新")
 need_restart = True
 continue
 elif os.path.isdir(path):
 try:
 shutil.rmtree(path)
 except PermissionError:
 print(f"警告: 目录 {path} 中的某些文件正在使用中，将在重启后更新")
 need_restart = True
 continue
 except Exception as e:
 print(f"删除 {path} 时出错: {str(e)}")
 continue
 # 如果需要重启，创建标记文件
 if need_restart:
 with open("need_restart", "w") as f:
 f.write("1")
 print("部分文件需要在重启后完成更新")
 return True # 仍然返回True，因为这是预期的行为

 # 复制新文件时添加错误处理
 for item in os.listdir(temp_dir):
 src = os.path.join(temp_dir, item)
 dst = os.path.join('.', item)
 try:
 if os.path.isfile(src):
 try:
 shutil.copy2(src, dst)
 except PermissionError:
 print(f"警告: 无法复制文件 {dst}，可能需要重启后完成更新")
 elif os.path.isdir(src):
 try:
 shutil.copytree(src, dst, dirs_exist_ok=True)
 except PermissionError:
 print(f"警告: 无法复制目录 {dst}，可能需要重启后完成更新")
 except Exception as e:
 print(f"复制 {src} 到 {dst} 时出错: {str(e)}")
 continue

 # 恢复需要保留的旧文件和文件夹
 for file in keep_files:
 temp_path = os.path.join(temp_dir, file)
 if os.path.exists(temp_path):
 # 如果是带路径的文件,先创建目录
 file_dir = os.path.dirname(file)
 if file_dir and not os.path.exists(file_dir):
 os.makedirs(file_dir)
 if os.path.isfile(temp_path):
 shutil.copy2(temp_path, file)
 elif os.path.isdir(temp_path):
 # 如果是文件夹则整个恢复
 if os.path.exists(file):
 shutil.rmtree(file)
 shutil.copytree(temp_path, file)

 return True
 except Exception as e:
 print(f"应用更新失败: {str(e)}, 错误位置: {e.__traceback__.tb_lineno}行")
 return False
 def cleanup(self, temp_dir="temp_update", backup_dir="backup"):
 """清理临时文件和备份"""
 try:
 if os.path.exists(temp_dir):
 shutil.rmtree(temp_dir)
 if os.path.exists(backup_dir):
 shutil.rmtree(backup_dir)
 if os.path.exists("update.zip"):
 os.remove("update.zip")
 except Exception as e:
 print(f"清理文件失败: {str(e)}")

 def update(self):
 """执行更新流程"""
 if not self.load_config():
 return False

 if not self.check_update():
 print("当前已是最新版本")
 return True

 print(f"发现新版本: {self.config['version']}")
 print("更新说明:")
 print(self.config['publish_notes'])

 # 下载更新
 update_file = self.download_update()
 if not update_file:
 return False
 print(f"下载更新文件: {update_file}")

 # 备份当前文件
 if not self.backup_files():
 return False
 print("备份完成")

 # 应用更新
 if not self.apply_update(update_file):
 print("更新失败，正在恢复备份...")
 if self.apply_update("backup"):
 print("恢复备份成功")
 self.cleanup()
 else:
 print("恢复备份失败，请手动恢复")
 return False

 # 清理临时文件和备份
 self.cleanup()
 print(f"更新完成！当前版本: {self.config['version']}")
 return True


if __name__ == "__main__":
 try:
 updater = AutoUpdater()
 update_result = updater.update()
 print("更新" + ("成功" if update_result else "失败"))
 except Exception as e:
 print(f"更新过程中发生错误: {str(e)}")
 finally:
 input("按任意键退出...")

此外，本地需要一个update.json文件，这个文件是用来记录当前版本的信息,这个和远程的内容是一样的，本地版本的配置文件里面的版本只有小于远程版本才会更新的

例如：

测试：

可以把上面的代码打包exe，然后运行，实际上就可以进行更新了，不过我们平常的使用方法应该是检查更新，如果没有更新就打开正常的界面，于是可以使用下面的代码

启动器代码

import os
import sys
import subprocess
import time
import shutil

def main():
 # 检查是否有更新程序在运行
 updater_path = "updater.exe"
 if os.path.exists(updater_path):
 # 运行更新程序
 subprocess.run([updater_path], check=True)

 # 如果更新成功且需要重启
 if os.path.exists("need_restart"):
 # 删除重启标记
 os.remove("need_restart")

 # 等待原程序完全退出
 time.sleep(2)

 # 完成未完成的更新操作
 if os.path.exists("temp_update"):
 for root, dirs, files in os.walk("temp_update"):
 for file in files:
 src = os.path.join(root, file)
 dst = os.path.join(root.replace("temp_update", ""), file)
 try:
 if os.path.exists(dst):
 os.remove(dst)
 shutil.copy2(src, dst)
 except Exception as e:
 print(f"更新文件失败: {e}")

 # 清理临时文件
 shutil.rmtree("temp_update")

 # 启动主程序
 main_program = "main.exe" # 替换为你的主程序名
 if os.path.exists(main_program):
 subprocess.run([main_program])

if __name__ == "__main__":
 main()

更完善的更新程序（更新和启动在一个文件里面）

# updater.py
import json
import hashlib
import os
import shutil
import requests
from pathlib import Path
import argparse
import subprocess
import tkinter as tk
from tkinter import messagebox, ttk
import psutil
import threading

parser = argparse.ArgumentParser()
parser.add_argument('--host', default="XXX.XXX.XXX.XXX", help="服务器IP地址或域名")
args = parser.parse_args()
YOUR_HOST = args.host

TARGET_APP = "launcher.exe"

class AutoUpdater:
 def __init__(self, config_path=f"http://{YOUR_HOST}/update_config"):
 self.config_path = config_path
 self.config = None
 with open('update.json', 'r', encoding='utf-8') as f:
 self.current_version = json.load(f)['version']

 def load_config(self):
 try:
 response = requests.get(self.config_path)
 self.config = response.json()
 return True
 except Exception as e:
 print(f"加载配置文件失败: {str(e)}")
 return False

 def check_update(self):
 if not self.config:
 return False
 return self.config['version'] != self.current_version

 def calculate_file_hash(self, file_path):
 hash_md5 = hashlib.md5()
 with open(file_path, "rb") as f:
 for chunk in iter(lambda: f.read(4096), b""):
 hash_md5.update(chunk)
 return hash_md5.hexdigest()

 def download_update(self, temp_dir="temp_update"):
 if not os.path.exists(temp_dir):
 os.makedirs(temp_dir)

 try:
 update_file = f"{temp_dir}/update.zip"
 download_route = self.config["download_url"]
 response = requests.get(f'http://{YOUR_HOST}{download_route}', stream=True)
 with open(update_file, 'wb') as f:
 for chunk in response.iter_content(chunk_size=8192):
 f.write(chunk)
 if self.calculate_file_hash(update_file) != self.config['file_hash']:
 print("文件验证失败！")
 return False
 return update_file
 except Exception as e:
 print(f"下载更新失败: {str(e)}")
 return False

 def backup_files(self, backup_dir="backup"):
 try:
 if not os.path.exists(backup_dir):
 os.makedirs(backup_dir)
 for item in os.listdir('.'):
 if item not in [backup_dir, 'temp_update', 'updater.exe','launcher.exe']:
 src = os.path.join('.', item)
 dst = os.path.join(backup_dir, item)
 if os.path.isfile(src):
 shutil.copy2(src, dst)
 elif os.path.isdir(src):
 shutil.copytree(src, dst)
 return True
 except Exception as e:
 print(f"备份文件失败: {str(e)}")
 return False

 def apply_update(self, update_file, temp_dir="temp_update"):
 try:
 shutil.unpack_archive(update_file, temp_dir)
 keep_files = self.config.get('keep_files', [])
 for file in keep_files:
 if os.path.exists(file):
 temp_path = os.path.join(temp_dir, f"{file}")
 temp_dir_path = os.path.dirname(temp_path)
 if temp_dir_path and not os.path.exists(temp_dir_path):
 os.makedirs(temp_dir_path)
 print(f"备份: {file} -> {temp_path}")
 if os.path.isfile(file):
 shutil.copy2(file, temp_path)
 elif os.path.isdir(file):
 shutil.copytree(file, temp_path)

 need_restart = False
 for item in os.listdir('.'):
 if item not in ['backup', 'temp_update', 'updater.exe','launcher.exe']:
 path = os.path.join('.', item)
 try:
 if os.path.isfile(path):
 try:
 os.remove(path)
 except PermissionError:
 print(f"警告: 文件 {path} 正在使用中，将在重启后更新")
 need_restart = True
 continue
 elif os.path.isdir(path):
 try:
 shutil.rmtree(path)
 except PermissionError:
 print(f"警告: 目录 {path} 中的某些文件正在使用中，将在重启后更新")
 need_restart = True
 continue
 except Exception as e:
 print(f"删除 {path} 时出错: {str(e)}")
 continue
 if need_restart:
 with open("need_restart", "w") as f:
 f.write("1")
 print("部分文件需要在重启后完成更新")
 return True

 for item in os.listdir(temp_dir):
 src = os.path.join(temp_dir, item)
 dst = os.path.join('.', item)
 try:
 if os.path.isfile(src):
 try:
 shutil.copy2(src, dst)
 except PermissionError:
 print(f"警告: 无法复制文件 {dst}")
 elif os.path.isdir(src):
 try:
 shutil.copytree(src, dst, dirs_exist_ok=True)
 except PermissionError:
 print(f"警告: 无法复制目录 {dst}")
 except Exception as e:
 print(f"复制 {src} 到 {dst} 时出错: {str(e)}")
 continue

 for file in keep_files:
 temp_path = os.path.join(temp_dir, file)
 if os.path.exists(temp_path):
 file_dir = os.path.dirname(file)
 if file_dir and not os.path.exists(file_dir):
 os.makedirs(file_dir)
 if os.path.isfile(temp_path):
 shutil.copy2(temp_path, file)
 elif os.path.isdir(temp_path):
 if os.path.exists(file):
 shutil.rmtree(file)
 shutil.copytree(temp_path, file)

 return True
 except Exception as e:
 print(f"应用更新失败: {str(e)}, 错误位置: {e.__traceback__.tb_lineno}行")
 return False

 def cleanup(self, temp_dir="temp_update", backup_dir="backup"):
 try:
 if os.path.exists(temp_dir):
 shutil.rmtree(temp_dir)
 if os.path.exists(backup_dir):
 shutil.rmtree(backup_dir)
 if os.path.exists("update.zip"):
 os.remove("update.zip")
 except Exception as e:
 print(f"清理文件失败: {str(e)}")

 def update(self):
 if not self.load_config():
 return False
 if not self.check_update():
 print("当前已是最新版本")
 return True

 print(f"发现新版本: {self.config['version']}")
 print("更新说明:")
 print(self.config['publish_notes'])

 update_file = self.download_update()
 if not update_file:
 return False
 print(f"下载更新文件: {update_file}")

 if not self.backup_files():
 return False
 print("备份完成")

 if not self.apply_update(update_file):
 print("更新失败，正在恢复备份...")
 if self.apply_update("backup"):
 print("恢复备份成功")
 self.cleanup()
 else:
 print("恢复备份失败，请手动恢复")
 return False

 self.cleanup()
 print(f"更新完成！当前版本: {self.config['version']}")
 return True

def is_process_running(process_name):
 for proc in psutil.process_iter(['name']):
 try:
 if proc.info['name'].lower() == process_name.lower():
 return True
 except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
 continue
 return False

def start_target_app():
 try:
 if os.path.exists(TARGET_APP):
 subprocess.Popen(TARGET_APP)
 else:
 messagebox.showerror("错误", f"找不到 {TARGET_APP}，请确保文件存在！")
 except Exception as e:
 messagebox.showerror("错误", f"启动 {TARGET_APP} 失败: {str(e)}")

def show_updating_window(root, updater, callback):
 update_window = tk.Toplevel(root)
 update_window.title("更新")
 update_window.geometry("300x100")
 update_window.resizable(False, False)

 # Center the window
 update_window.update_idletasks()
 width = update_window.winfo_width()
 height = update_window.winfo_height()
 x = (update_window.winfo_screenwidth() // 2) - (width // 2)
 y = (update_window.winfo_screenheight() // 2) - (height // 2)
 update_window.geometry(f'+{x}+{y}')

 label = ttk.Label(update_window, text="正在更新，请稍候...")
 label.pack(pady=20)

 progress = ttk.Progressbar(update_window, mode='indeterminate')
 progress.pack(pady=10, padx=20, fill='x')
 progress.start()

 # Run update in a separate thread
 def run_update():
 result = updater.update()
 root.after(0, lambda: finish_update(result, update_window, callback))

 thread = threading.Thread(target=run_update)
 thread.start()

 return update_window

def finish_update(result, update_window, callback):
 update_window.destroy()
 callback(result)

if __name__ == "__main__":
 root = tk.Tk()
 root.withdraw()

 try:
 updater = AutoUpdater()
 if not updater.load_config():
 messagebox.showerror("错误", "无法加载更新配置，请检查网络或服务器状态")
 elif not updater.check_update():
 # messagebox.showinfo("更新结果", "当前已是最新版本")
 start_target_app()
 else:
 while is_process_running(TARGET_APP):
 response = messagebox.askyesno("提示", f"{TARGET_APP} 正在运行，请关闭它以继续更新。\n是否重试？")
 if not response:
 root.destroy()
 exit()

 def update_callback(result):
 if result:
 messagebox.showinfo("更新结果", f"更新成功！当前版本: {updater.config['version']}")
 start_target_app()
 else:
 messagebox.showerror("更新结果", "更新失败，请查看日志或联系管理员")

 # Show updating window and run update in thread
 show_updating_window(root, updater, update_callback)
 root.mainloop() # Keep the GUI running
 exit() # Exit after mainloop ends
 except Exception as e:
 messagebox.showerror("错误", f"更新过程中发生错误: {str(e)}")

 root.destroy()

项目实战 on 扎塔-Zata

ai-crawler-深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

深度调研报告：人工智能驱动的网络爬虫技术——能力、应用与生态演进

1. 执行摘要

2. 背景与技术范式转移

2.1 传统爬虫的局限性与“脆性”危机

2.2 生成式 AI 与大语言模型的介入

3. 核心技术能力与架构解析

3.1 基于 LLM 的 HTML 解析与非结构化数据提取

3.1.1 工作原理

3.1.2 DOM 降采样（Downsampling）与上下文管理

3.2 视觉驱动的提取与多模态融合

3.2.1 视觉页面分割（VIPS）

3.2.2 标记集提示（Set-of-Mark Prompting）

3.3 自主智能体（Autonomous Web Agents）

3.3.1 ReAct 范式与思维链

3.3.2 跨站协同与自我修复

4. 主流 AI 爬虫框架与工具深度评测

4.1 Firecrawl：RAG 数据管道的基石

4.2 ScrapeGraphAI：模块化与本地化的先锋

4.3 Crawl4AI：速度与开源的极致

4.4 Skyvern：视觉驱动的流程自动化

5. 对抗技术：反爬虫与防御机制的进化

5.1 行为生物识别（Behavioral Biometrics）

5.2 AI 抗性验证码（AI-Resistant CAPTCHAs）

5.3 “Agent 失明”危机（Blinded by the Agent）

6. 经济模型与成本分析

6.1 Token 经济学

6.2 维护成本的节省

7. 法律、伦理与合规新秩序

7.1 版权与“合理使用”的法律博弈

7.2 协议的演进：robots.txt vs ai.txt

7.3 GDPR 与隐私合规

8. 应用案例与行业影响

8.1 市场情报与动态定价

8.2 金融替代数据（Alternative Data）

8.3 销售线索生成（Lead Enrichment）

9. 未来展望：群体智能与 Agentic Web

9.1 多智能体群体（Multi-Agent Swarms）

9.2 协议化与“Agentic Web”的诞生

10. 结论

在 2024 年末到 2026 年初（当前时间点），“AI 爬虫”的概念已经发生了巨大的变化。

第一梯队：RAG 专用爬虫（目前最火）

1. Crawl4AI (Python)

2. Firecrawl

3. Jina Reader (r.jina.ai)

第二梯队：Agentic Web Browsers（智能操作型）

1. Stagehand

2. Skyvern

第三梯队：基础设施与抗指纹 (Infrastructure)

总结：我该选哪个？

下一步建议

AI 爬虫全景技术指南 (2025/2026 版)

1. 核心分类：根据需求选工具

2. 热门工具详解与代码思路

A. RAG 最佳拍档：Crawl4AI (Python)

B. 最简 API：Jina Reader

C. 复杂交互爬虫推荐：DrissionPage

D. 智能体方案：Browser-Use (LangChain + Playwright)

3. 针对“高难度”场景的解决方案

推荐技术栈排序

4. 模型选择：给 Agent 配个好大脑

💰 付费/最强王者

🆓 免费/平替方案 (推荐)

5. 总结建议

crawler-爬虫ip代理商

参考资料

代理商

快代理

亮数据

使用自己的VPN去做代理

爬虫中使用

crawler-tutorial

第一部分：主流爬虫框架/库对照

第二部分：高难度场景（验证码 + 强反爬）解决方案

告别手动写爬虫代码-从F12到Python

微信小程序使用教程——WechatMiniProgram

第一部分：微信小程序简介

特点：

第二部分：准备工作

7-（第一节）新建工程模板-寄存器版

5. 主爬取函数 `crawl`