1. 项目概述：从“爬取”到“数据资产”的认知跃迁

“财联社新闻爬取核心代码”这个标题，乍一看像是一个纯粹的技术实现问题，但背后折射出的，是金融信息领域一个永恒且核心的需求：如何高效、稳定、合规地获取第一手的市场资讯。在信息即财富的金融市场，新闻的时效性和准确性直接关联着决策的质量。无论是个人投资者、量化团队，还是金融科技公司的数据中台，都需要一个可靠的新闻数据源作为分析的基石。财联社作为国内领先的财经资讯平台，其发布的快讯、深度报道、行业动态，无疑是极具价值的数据金矿。

然而，爬取财经新闻远非一个简单的 requests.get() 就能搞定。它涉及反爬对抗、数据结构化解析、增量更新策略、数据清洗与存储等一系列复杂环节。所谓的“核心代码”，绝不是几行简单的请求和解析，而是一套包含工程化思维、稳定性保障和风险规避的完整解决方案。本文将从一个有多年数据采集经验的从业者视角，深入拆解构建一个健壮的财联社新闻爬虫所需的核心模块、技术选型背后的考量，以及那些在官方文档里找不到的实战心得与避坑指南。无论你是想为自己的量化策略补充新闻因子，还是为公司的数据产品构建底层数据管道，这篇文章都将提供一条清晰的实现路径。

2. 整体架构设计与技术选型背后的逻辑

构建一个生产级别的新闻爬虫，首要任务不是写代码，而是设计一个能应对各种挑战的架构。一个鲁棒的爬虫系统，其核心目标可以概括为： 在遵守目标网站规则的前提下，以尽可能高的成功率、稳定性和效率，获取结构化的高质量数据 。围绕这个目标，我们的架构需要解决几个关键问题：如何突破或绕过反爬机制？如何高效地解析动态渲染的页面？如何设计一个永不重复、永不遗漏的抓取逻辑？数据如何存储以便后续分析？

2.1 核心工具链选型：为什么是它们？

在Python生态中，爬虫工具琳琅满目，但针对财联社这类可能具备一定反爬措施的现代新闻网站，我们的选择需要格外谨慎。

• 请求库： requests 与 httpx 的权衡 requests 是毋庸置疑的经典，其API设计优雅，社区资源丰富。但对于需要处理大量并发请求或HTTP/2支持的场景， httpx 表现出色。财联社的新闻列表页和详情页抓取，通常并发需求不高，但稳定性要求高。因此， requests 仍是稳妥的首选 。它的成熟度意味着更少的未知错误，且易于集成会话（Session）管理来维持Cookie和连接池，这对需要维持登录状态或应对某些反爬策略很有帮助。

• 解析库： lxml 与 parsel 的效率之争 BeautifulSoup 适合初学者，但在处理大量HTML文档时，其解析速度是短板。 lxml 凭借C语言实现，解析速度极快，是高性能爬虫的标配。而 parsel （Scrapy框架的解析组件）在 lxml 之上提供了更便捷的CSS和XPath选择器链式调用，写起来非常流畅。对于财联社，其页面结构通常比较规整， 直接使用 lxml 的XPath进行解析，能在开发效率和运行效率间取得最佳平衡 。XPath的路径表达式能精准定位到标题、发布时间、正文等元素。

• 动态渲染应对： Selenium 还是 Playwright / DrissionPage ？ 这是关键决策点。如果财联社的新闻内容直接包含在初始HTML响应中（即“静态”页面），那么上述组合就够了。但越来越多的网站采用JavaScript动态加载内容。这时我们需要能控制真实浏览器的工具。

  • Selenium : 老牌工具，生态成熟，但速度较慢，资源占用高。
  • Playwright : 后起之秀，由微软开发，支持多浏览器（Chromium, Firefox, WebKit），API现代化，性能和控制能力更强。
  • DrissionPage : 一个新兴的国产库，它创新性地将浏览器驱动和请求包合二为一，既能在需要时切换到浏览器渲染，又能直接用请求模式获取数据， 在效率和便利性上取得了巧妙的平衡 ，特别适合对付那些“大部分内容静态，关键数据动态”的网站。

  实操心得 ：首先用 requests 尝试抓取，检查返回的HTML是否包含完整新闻正文。如果不包含，再考虑使用 DrissionPage 。它的混合模式允许我们先用Session模式（类似requests）快速获取页面框架，如果发现目标数据是动态加载的，可以无缝切换到浏览器模式获取，这样比全程无头浏览器节省大量资源。

• 数据存储：SQLite 还是 MySQL/PostgreSQL？ 这取决于数据量和应用场景。对于个人研究或中小型项目， SQLite 是完美选择，它无需安装数据库服务器，单个文件管理，简单可靠。对于需要多线程/进程并发写入或数据量非常庞大的团队项目，则应选择 PostgreSQL 或 MySQL 。新闻数据通常是追加式的，表结构设计简单，核心字段包括： id （主键）、 title （标题）、 publish_time （发布时间）、 content （正文）、 source （来源，如“财联社”）、 url （原文链接，唯一索引）、 crawl_time （爬取时间）等。

2.2 核心流程设计：一个永不迷路的抓取循环

一个健壮的爬虫流程应该像一台精密的钟表，循环往复且能自我修正。其核心循环如下：

1. 种子URL管理 ：维护一个待抓取队列。初始种子可以是财联社的某个频道首页（如快讯列表）。
2. 调度与下载 ：从队列中取出URL，根据URL类型（列表页、详情页）分发给不同的下载器（静态下载器或动态渲染下载器）。
3. 解析与抽取 ：下载成功后，解析页面。列表页解析出新闻标题、链接、发布时间，并将新链接放入待抓取队列；详情页解析出完整的新闻正文、作者等。
4. 数据去重与存储 ：利用URL的唯一性，在存储前进行去重判断，防止重复抓取。然后将结构化数据存入数据库。
5. 异常处理与重试 ：对网络超时、解析失败等异常进行捕获，并设计重试机制（如最多重试3次，每次间隔递增）。
6. 礼貌爬取 ：在请求间插入随机延时（如 time.sleep(random.uniform(1, 3)) ），遵守 robots.txt 规则，避免对目标服务器造成压力。

注意 ：绝对不要在代码中设置过短的请求间隔或尝试绕过明显的反爬措施（如验证码）。这不仅关乎道德和法律风险，从长远看，维持一个稳定的数据源远比一次性暴力抓取重要得多。

3. 核心代码模块拆解与实现细节

下面，我们抛开理论，直接进入核心代码环节。我将分模块展示关键代码，并解释每一行背后的意图和可能遇到的坑。

3.1 请求会话与头信息伪装

这是爬虫的“门面”，决定了服务器对你的第一印象。

import requests
import time
import random
from lxml import etree

class CaiLianSheSpider:
    def __init__(self):
        # 创建一个会话对象，可以自动管理cookies，提升效率
        self.session = requests.Session()
        # 定义一组请求头，模拟真实浏览器
        self.headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
            'Accept-Encoding': 'gzip, deflate, br',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1',
        }
        self.session.headers.update(self.headers)
        # 基础URL，用于拼接
        self.base_url = 'https://www.cls.cn'
        
    def _request_with_retry(self, url, max_retries=3, timeout=10):
        """带重试机制的请求函数"""
        for attempt in range(max_retries):
            try:
                resp = self.session.get(url, timeout=timeout)
                resp.raise_for_status()  # 如果状态码不是200，抛出HTTPError异常
                # 简单检查内容是否被反爬（例如返回了验证页面）
                if "验证" in resp.text or "access denied" in resp.text.lower():
                    raise Exception("页面可能触发了反爬机制")
                return resp
            except (requests.exceptions.RequestException, Exception) as e:
                print(f"请求 {url} 失败，第 {attempt+1} 次重试。错误: {e}")
                if attempt == max_retries - 1:
                    raise  # 重试次数用尽，抛出异常
                sleep_time = (attempt + 1) * 2 + random.random()  # 退避策略
                time.sleep(sleep_time)
        return None

关键点解析 ：

• 会话（Session） ：使用 requests.Session() 可以保持跨请求的Cookie，有些网站会利用Session来跟踪访客状态。
• User-Agent ：这是最基本的伪装。使用一个常见的浏览器UA字符串，避免使用默认的 python-requests 。
• 重试机制 ：网络请求充满不确定性。 _request_with_retry 函数封装了重试逻辑，并采用了“指数退避”策略，避免在服务器临时故障时持续轰炸。
• 响应检查 ：在返回响应前，简单检查页面内容是否包含“验证”等关键字，这是一种初级但有效的反爬触发感知。

3.2 列表页解析与链接发现

财联社的快讯列表页是新闻的入口。我们需要从中提取出每条快讯的链接和发布时间。

    def parse_news_list(self, html_content):
        """解析新闻列表页，提取文章链接和基本信息"""
        news_items = []
        try:
            # 使用lxml解析HTML
            html = etree.HTML(html_content)
            # 这里需要根据财联社实际页面结构调整XPath
            # 示例XPath，需通过浏览器开发者工具实际分析确定
            # 假设每条新闻在一个class为‘news-item’的div里
            item_nodes = html.xpath('//div[contains(@class, "news-item")]')
            
            for node in item_nodes:
                try:
                    # 提取标题和链接
                    title_elem = node.xpath('.//a[contains(@class, "title")]/text()')
                    link_elem = node.xpath('.//a[contains(@class, "title")]/@href')
                    time_elem = node.xpath('.//span[contains(@class, "time")]/text()')
                    
                    if title_elem and link_elem and time_elem:
                        title = title_elem[0].strip()
                        # 链接可能是相对路径，需要拼接
                        relative_link = link_elem[0].strip()
                        full_url = requests.compat.urljoin(self.base_url, relative_link)
                        publish_time = time_elem[0].strip()
                        
                        news_items.append({
                            'title': title,
                            'url': full_url,
                            'publish_time': publish_time
                        })
                except (IndexError, AttributeError) as e:
                    # 单条新闻解析失败，记录日志并继续
                    print(f"解析单条新闻时出错: {e}")
                    continue
        except etree.XMLSyntaxError as e:
            print(f"HTML解析失败: {e}")
            return []
        
        return news_items

实操心得 ：

• XPath的获取 ：不要凭空编写XPath。务必使用Chrome浏览器的“开发者工具”（F12），通过“检查元素”和“Copy -> Copy XPath”功能来获取，但复制出来的路径往往过于冗长且脆弱（依赖于完整层级）。 更好的方法是观察元素的特征 ，使用包含特定class或属性的相对路径，如 //div[@class="article-list"]//h3/a 。这样即使页面局部结构微调，爬虫仍能工作。
• 健壮性 ：在解析循环内部进行 try...except ，确保一条新闻解析失败不会导致整个任务崩溃。同时，对提取到的文本进行 .strip() 清理空白字符。
• URL拼接 ：使用 requests.compat.urljoin 可以智能地处理相对路径和绝对路径的拼接，避免自己手动处理 ../ 等复杂情况。

3.3 详情页正文提取与清洗

获取到链接后，下一步是抓取详情页并提取纯净的正文。

    def parse_news_detail(self, html_content, url):
        """解析新闻详情页，提取正文内容"""
        detail_info = {'url': url, 'content': '', 'source': '财联社'}
        try:
            html = etree.HTML(html_content)
            # 再次强调：此XPath需根据实际页面调整
            # 尝试定位正文主体区域
            content_node = html.xpath('//div[@class="article-content"] | //div[contains(@class, "content")]')
            
            if content_node:
                # 获取该节点下所有文本（包括子节点的文本）
                raw_content = ''.join(content_node[0].xpath('.//text()'))
                # 清洗内容：去除多余空白、换行，替换特殊字符
                cleaned_content = self._clean_text(raw_content)
                detail_info['content'] = cleaned_content
            else:
                # 如果常规XPath找不到，可能是动态加载，记录下来后续处理
                print(f"警告：未能在页面 {url} 中找到正文内容，可能是动态加载。")
                detail_info['content'] = '[动态内容需浏览器渲染]'
                
            # 可以尝试提取更精确的发布时间、作者等
            # pub_time = html.xpath('//meta[@property="article:published_time"]/@content')
            # detail_info['publish_time'] = pub_time[0] if pub_time else None
            
        except Exception as e:
            print(f"解析详情页 {url} 时发生错误: {e}")
            
        return detail_info
    
    def _clean_text(self, text):
        """清洗文本，去除无用字符"""
        import re
        # 合并多个空白字符为一个空格
        text = re.sub(r'\s+', ' ', text)
        # 去除首尾空格
        text = text.strip()
        # 可以在这里添加更多清洗规则，如过滤广告文本等
        return text

常见问题与技巧 ：

• 正文定位不准 ：新闻正文可能被包裹在多个层级的 div 中。除了用class定位，还可以尝试用更通用的方法，比如寻找包含大量文本且没有 <script> 标签的最大 <div> 。或者， 查看网页源代码，搜索 <article> 标签 ，很多新闻网站会用这个语义化标签包裹正文。
• 动态内容处理 ：如果 parse_news_detail 返回 [动态内容需浏览器渲染] ，就需要启动备用方案——使用 DrissionPage 或 Playwright 。

    def parse_dynamic_detail(self, url):
        """使用DrissionPage处理动态加载的详情页"""
        from DrissionPage import SessionPage, ChromiumPage
        
        detail_info = {'url': url, 'content': ''}
        # 方案1：先尝试Session模式（更快）
        page = SessionPage()
        page.get(url)
        # 检查页面是否已包含所需内容
        if "文章正文" in page.html:  # 替换为实际判断逻辑
            # 用lxml解析page.html
            detail_info = self.parse_news_detail(page.html, url)
        else:
            # 方案2：切换到浏览器模式渲染
            print(f"切换到浏览器模式渲染: {url}")
            page.change_mode('d')  # 切换到驱动模式（浏览器）
            # 这里page对象已变为ChromiumPage，需要重新get
            # 注意：DrissionPage的API可能会更新，请以最新文档为准
            # 假设我们重新获取页面
            page.get(url)
            # 等待可能动态加载的元素
            page.wait.ele_displayed('tag:div@class=article-content', timeout=5)
            # 获取渲染后的HTML
            rendered_html = page.html
            detail_info = self.parse_news_detail(rendered_html, url)
            page.quit()  # 关闭浏览器，释放资源
            
        return detail_info

3.4 数据存储与去重策略

数据抓取后，需要持久化存储。这里以SQLite为例。

import sqlite3
from datetime import datetime

class NewsDatabase:
    def __init__(self, db_path='news.db'):
        self.conn = sqlite3.connect(db_path)
        self._create_table()
        
    def _create_table(self):
        """创建新闻表"""
        create_table_sql = """
        CREATE TABLE IF NOT EXISTS cls_news (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            title TEXT NOT NULL,
            url TEXT UNIQUE NOT NULL,  -- 唯一约束，用于去重
            publish_time TEXT,
            content TEXT,
            source TEXT DEFAULT '财联社',
            crawl_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        );
        CREATE INDEX IF NOT EXISTS idx_url ON cls_news(url);
        CREATE INDEX IF NOT EXISTS idx_publish_time ON cls_news(publish_time);
        """
        self.conn.executescript(create_table_sql)
        self.conn.commit()
        
    def insert_news(self, news_item):
        """插入单条新闻，基于URL去重"""
        insert_sql = """
        INSERT OR IGNORE INTO cls_news (title, url, publish_time, content, source)
        VALUES (?, ?, ?, ?, ?)
        """
        try:
            cursor = self.conn.cursor()
            cursor.execute(insert_sql, (
                news_item.get('title'),
                news_item.get('url'),
                news_item.get('publish_time'),
                news_item.get('content'),
                news_item.get('source', '财联社')
            ))
            self.conn.commit()
            if cursor.rowcount > 0:
                print(f"新增新闻: {news_item.get('title')[:30]}...")
                return True
            else:
                print(f"重复新闻，已跳过: {news_item.get('title')[:30]}...")
                return False
        except sqlite3.Error as e:
            print(f"数据库插入错误: {e}")
            self.conn.rollback()
            return False

核心设计 ：

• URL唯一索引 ： url TEXT UNIQUE NOT NULL 是关键。配合 INSERT OR IGNORE 语句，可以实现插入时自动去重。这是最简单有效的去重方法。
• 索引优化 ：为 url 和 publish_time 创建索引，能大幅提高根据URL查询和按时间范围检索的速度。
• 错误处理与事务 ：使用 try...except 捕获数据库错误，并在出错时回滚，保证数据一致性。

4. 工程化进阶：让爬虫稳定运行

一个能在生产环境跑起来的爬虫，还需要考虑更多。

4.1 增量抓取与定时调度

我们不可能每次都全量抓取。增量抓取的核心是 识别新内容 。财联社的列表页通常是按时间倒序排列的。

    def incremental_crawl(self, list_url, db, max_pages=5):
        """增量抓取列表页，直到遇到已存在的新闻"""
        page_num = 1
        while page_num <= max_pages:
            # 构建分页URL，例如 https://www.cls.cn/telegraph?page=2
            if page_num == 1:
                current_url = list_url
            else:
                current_url = f"{list_url}?page={page_num}"  # 实际分页参数需分析网站
            
            print(f"正在抓取列表页: {current_url}")
            resp = self._request_with_retry(current_url)
            if not resp:
                break
                
            news_list = self.parse_news_list(resp.text)
            if not news_list:
                break
                
            new_count = 0
            for news in news_list:
                # 先检查数据库中是否已存在该URL
                # 更高效的做法是批量检查，这里为清晰起见单条处理
                if self._is_news_exist(db, news['url']):
                    print(f"遇到已存在新闻，停止当前列表页抓取。")
                    return  # 发现重复，停止整个增量抓取
                # 抓取详情页
                detail_resp = self._request_with_retry(news['url'])
                if detail_resp:
                    detail_info = self.parse_news_detail(detail_resp.text, news['url'])
                    # 如果静态解析失败，尝试动态解析
                    if not detail_info.get('content') or '[动态内容]' in detail_info.get('content'):
                        detail_info = self.parse_dynamic_detail(news['url'])
                    detail_info['title'] = news['title']
                    detail_info['publish_time'] = news['publish_time']
                    if db.insert_news(detail_info):
                        new_count += 1
                # 礼貌延时
                time.sleep(random.uniform(1, 2))
            
            print(f"第{page_num}页抓取完成，新增{new_count}条。")
            if new_count == 0:
                # 本页没有新内容，可能已经抓取到最新了
                break
            page_num += 1
            # 翻页延时
            time.sleep(random.uniform(2, 4))

策略解析 ：这个函数会逐页抓取列表，并逐条检查新闻URL是否已在数据库中。一旦发现某条新闻已存在，就认为已经抓取到了上次停止的地方，于是停止抓取。这是一种简单有效的增量策略。更复杂的策略可以基于发布时间戳。

4.2 反爬应对与伦理边界

财联社作为专业平台，反爬措施可能包括：请求频率限制、IP封禁、验证码、请求头校验、参数签名等。

• 频率控制 ：如前所述，在请求间加入随机延时 ( time.sleep(random.uniform(1, 3)) ) 是最基本的尊重。
• IP代理池 ：如果单IP被抓取频率过高，可以考虑使用代理IP。但 务必使用合法合规的代理服务 ，并做好代理IP的可用性检测和切换。
• 请求头完善 ：模拟更完整的浏览器指纹，如 Referer , Accept-Encoding , Cookie （谨慎使用，避免涉及用户隐私）。
• 遵守robots.txt ：访问 https://www.cls.cn/robots.txt ，查看网站允许或禁止爬取的目录。虽然这不是法律文件，但遵守它是良好的网络公民行为。

重要提示 ：本文所有代码示例仅供学习和技术交流之用。在实际操作中，请务必：

1. 仔细阅读并遵守目标网站的 robots.txt 协议和服务条款。
2. 将请求频率控制在极低水平，避免对目标网站的正常运营造成任何影响。
3. 不得将爬取的数据用于任何商业用途或非法目的。
4. 尊重数据版权和知识产权。

4.3 日志记录与监控

一个无人值守的爬虫必须有眼睛和耳朵。使用Python内置的 logging 模块记录运行状态、错误信息。

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('crawl.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

# 在代码中替换print为logger
logger.info(f"正在抓取列表页: {current_url}")
logger.warning(f"未能在页面 {url} 中找到正文内容。")
logger.error(f"数据库插入错误: {e}")

5. 常见问题排查与实战心得

即使代码写得再完美，在实际运行中也会遇到各种意想不到的问题。下面是一些典型场景和解决思路。

5.1 问题：返回的HTML是空白的，或者是一段JavaScript代码。

• 排查 ：用浏览器打开目标URL，按F12打开“网络”选项卡，清空后刷新页面。查看第一个文档（ doc 类型）请求的响应是什么。如果和爬虫获取的一致，说明网站需要执行JS才能生成内容。
• 解决 ：切换到浏览器自动化工具，如 DrissionPage 或 Playwright ，等待页面加载完成后再获取HTML。

5.2 问题：请求频繁返回403/429状态码。

• 排查 ：检查请求头是否完整，特别是 User-Agent 。检查请求频率是否过高。
• 解决 ：
  1. 增加请求延时，并使其更加随机化。
  2. 轮换不同的 User-Agent 字符串（可以从网上找列表）。
  3. 检查网站是否要求特定的 Referer 头，模拟从站内跳转过来的请求。
  4. 如果问题持续，考虑使用代理IP，并确保代理IP本身是干净可用的。

5.3 问题：XPath昨天还能用，今天解析不到数据了。

• 排查 ：网站前端页面结构改版了。
• 解决 ：
  1. 不要写死XPath ：尽量使用相对宽松的、基于元素关键属性的定位方式，例如 //div[contains(@class, 'article')]//h1 比 //html/body/div[3]/div[2]/div[1]/h1 健壮得多。
  2. 准备备用方案 ：为关键字段（如标题、正文）设计2-3套不同的XPath或CSS选择器，主方案失败后尝试备用方案。
  3. 引入自动检测 ：写一个简单的健康检查函数，定期用已知的测试URL跑一下，如果核心字段解析失败，则触发告警（如发送邮件），通知维护人员。

5.4 问题：抓取到的正文包含大量无关内容（广告、推荐、版权声明）。

• 解决 ：在 _clean_text 函数中加强清洗逻辑。可以：
  1. 通过观察，找出广告块的独特特征（如特定的class名、id），在解析时直接排除这些节点。 lxml 的XPath支持 not() 函数，例如 //div[@class="content"]//*[not(contains(@class, "ad"))]//text() 。
  2. 基于规则过滤：删除包含“广告”、“推荐阅读”、“免责声明”等关键词的段落。
  3. （高级）使用机器学习方法进行正文提取，例如 readability-lxml 或 trafilatura 库，它们能智能识别网页的主要内容区域。

5.5 个人实战心得

1. 从简单开始，逐步复杂 ：先用最简单的 requests + lxml 尝试，能解决80%的问题。遇到动态加载再上 DrissionPage 。不要一开始就上最重的工具。
2. 保存原始HTML ：在解析函数中，如果遇到解析失败，可以将当时的 html_content 保存到文件里。事后分析这个文件，比反复抓取调试要高效得多。
3. 设计可配置的爬虫 ：将XPath、CSS选择器、请求头、延时参数等提取到配置文件（如 config.yaml ）或类属性中。当网站改版时，你只需要修改配置，而无需深入代码逻辑。
4. 重视数据质量 ：爬虫的终点不是数据库，而是可用的数据。定期抽样检查入库数据的完整性、准确性。建立简单的数据质量监控，比如检查正文长度是否过短、发布时间格式是否异常等。
5. 拥抱变化 ：网站反爬策略和前端技术都在演进。保持爬虫代码的模块化和可维护性，当需要更换请求库、解析方式甚至整个抓取策略时，能够以最小成本进行迭代。

构建一个可靠的财经新闻爬虫，技术实现只是骨架，而对数据流的理解、对稳定性的追求、对规则的敬畏，才是赋予其灵魂的关键。这套“核心代码”提供的不仅是一套可运行的脚本，更是一种应对数据获取挑战的系统性思维方式。