1. 为什么你需要一个自动化工具？

如果你经常在社交媒体上寻找视频素材，或者需要分析某个话题下的视频传播趋势，那你肯定有过这样的经历：手动一个个点开推文，寻找视频，再复制链接。这个过程不仅枯燥，而且效率极低。想象一下，你需要分析“#人工智能”这个话题下过去一周的所有热门视频，手动操作可能要花上好几个小时，而且很容易遗漏。这时候，一个能自动帮你完成这些重复性工作的工具就显得尤为重要了。

我最初有这个需求，是因为在做一些市场分析项目。客户想知道某个产品在社交媒体上的视频曝光情况，手动收集了几十条推文后，我就彻底放弃了。太费时间了，而且数据还不全。于是，我开始研究用Python来自动化这个流程。今天我要分享的，就是我这几年摸索下来，一套比较成熟、稳定且高效的自动化抓取Twitter视频链接的方案。它特别适合数据分析师、内容运营或者任何需要批量处理社交媒体视频的朋友。你不用有很深的编程基础，跟着我的步骤，一步步来，就能搭建起属于你自己的“视频采集机器人”。

这个工具的核心思路很简单：模拟我们手动操作的过程，但交给程序去执行。程序会代替我们去搜索关键词，浏览搜索结果，从每一条推文里找出视频链接，并把这些链接整齐地保存下来。整个过程完全自动化，你可以设置好之后就去喝杯咖啡，回来数据就收集好了。接下来，我们就从最基础的环境搭建开始。

2. 搭建你的Python工作环境

工欲善其事，必先利其器。在开始写代码之前，我们需要先把“厨房”收拾好，把需要的“食材”和“厨具”准备齐全。别担心，这个过程就像安装手机APP一样简单。

2.1 Python安装与包管理

首先，确保你的电脑上安装了Python。我强烈推荐使用Python 3.7或更高的版本，因为很多新库对老版本的支持不太好。你可以打开命令行（Windows上是CMD或PowerShell，Mac或Linux上是终端），输入 python --version 来检查。如果显示版本号，那就没问题。如果没有，你需要去Python官网下载安装包。安装时，记得勾选“Add Python to PATH”这个选项，这能省去后面配置环境变量的麻烦。

Python自带了一个强大的包管理工具叫 pip，我们需要的所有库都通过它来安装。为了安装过程更顺畅，我建议先把pip升级到最新版。在命令行里输入：

python -m pip install --upgrade pip

这行命令会让pip自己更新自己。有时候网络问题可能导致安装失败，如果遇到速度慢或者超时，可以尝试使用国内的镜像源，比如清华的源：

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple --upgrade pip

2.2 核心库的安装与介绍

接下来，我们要安装三个核心的Python库，它们是我们这个工具的“三驾马车”。

1. Tweepy：这是与Twitter官方API交互的“桥梁”。它把复杂的API调用封装成了简单的Python函数，让我们能用几行代码就完成认证、搜索、获取推文等操作。没有它，我们直接去调用Twitter API会非常麻烦。
2. Requests：这是一个HTTP库，被誉为“人类使用的HTTP”。当我们需要直接访问某些网页来解析视频链接，或者Tweepy无法满足一些高级需求时，Requests库就能派上用场。它简单易用，功能强大。
3. BeautifulSoup4：这是我们的“解析神器”。Twitter返回的推文数据里，视频信息通常嵌套在HTML或复杂的JSON结构中。BeautifulSoup可以像一把手术刀，精准地从这些杂乱的结构里把视频链接“解剖”出来。

安装它们只需要一行命令。在命令行中依次执行：

pip install tweepy
pip install requests
pip install beautifulsoup4

如果你想像我一样，喜欢用一个命令搞定所有，也可以这样：

pip install tweepy requests beautifulsoup4

看到“Successfully installed”的字样，就说明安装成功了。为了验证安装，你可以打开Python的交互环境（在命令行输入 python），然后分别输入 import tweepy， import requests， import bs4（BeautifulSoup的导入名）。如果没有报错，那么恭喜你，环境搭建已经完成了最重要的一步。

3. 获取Twitter API访问钥匙

要想让程序合法地、稳定地从Twitter获取数据，我们必须使用官方提供的API。这就好比你要进一个高级俱乐部，必须得有会员卡一样。Twitter API就是我们的“会员卡”。获取它的过程是免费的，但需要你注册并创建一个应用。

3.1 创建Twitter开发者账号与应用

首先，用你的Twitter账号登录 Twitter开发者平台。如果你之前没注册过开发者账号，它会引导你完成注册流程，你需要填写一些基本信息，比如你使用API的目的。我一般选择“学术研究”或“制作机器人工具”，并简单描述“用于自动化收集公开的社交媒体视频数据进行内容分析”，这样通常都能顺利通过。

登录后，点击右上角的“Developer Portal”进入控制台。然后，找到“Projects & Apps”选项，点击“Create App”。这里要注意，Twitter现在以“Project”为单位管理应用。你需要先创建一个Project，然后在这个Project下创建你的第一个App。

给App起一个你能记住的名字，比如“MyVideoScraper”。其他信息如描述、网站URL（如果你没有，可以填 https://example.com）按实际情况填写即可。创建成功后，你就来到了App的管理页面。这里最重要的就是“Keys and Tokens”标签页。

3.2 理解并保存四把密钥

在“Keys and Tokens”页面，你会看到四串由字母和数字组成的长字符串，这就是我们程序的“钥匙”。请务必像保管密码一样保管好它们，千万不要泄露或上传到公开的代码仓库（如GitHub）。我习惯把它们保存在本地的密码管理器或者一个单独的、不会被上传的配置文件中。

这四把钥匙分别是：

• API Key 和 API Key Secret：这一对可以理解为你的App的“用户名和密码”。它代表了你的应用身份。
• Access Token 和 Access Token Secret：这一对是“访问令牌”。它代表了授权你这个应用访问特定Twitter账号数据的权限。在创建App时，系统会自动为你生成一对。

把它们记录下来，我们马上就会在代码里用到。有了这四把钥匙，我们的程序就获得了Twitter官方的“通行证”，可以开始正式工作了。相比于一些需要模拟浏览器、容易被封禁的非正规方法，使用API是最稳定、最合规的方式。

4. 编写核心抓取脚本

环境好了，钥匙也有了，现在让我们开始动手编写最核心的代码部分。我会把代码拆解成几个小块，并详细解释每一行是干什么的，确保你不仅能复制粘贴，更能真正理解。

4.1 初始化API客户端

首先，我们需要用刚才获取的密钥来“启动”Tweepy，让它帮我们建立与Twitter服务器的连接。新建一个Python文件，比如叫做 twitter_video_scraper.py。

import tweepy
import requests
from bs4 import BeautifulSoup
import time
import json

# 1. 替换成你自己的API密钥
CONSUMER_KEY = '你的API_KEY'
CONSUMER_SECRET = '你的API_KEY_SECRET'
ACCESS_TOKEN = '你的ACCESS_TOKEN'
ACCESS_TOKEN_SECRET = '你的ACCESS_TOKEN_SECRET'

# 2. 身份认证
auth = tweepy.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)

# 3. 创建API客户端对象
api = tweepy.API(auth, wait_on_rate_limit=True)

这段代码做了三件事：

1. 定义了四个变量，存放你的密钥。切记要把单引号里的内容换成你实际申请到的字符串。
2. 使用 OAuthHandler 进行OAuth 1.0a认证，这是Twitter API要求的认证方式。
3. 用认证信息创建了一个API客户端对象。参数 wait_on_rate_limit=True 非常重要，它告诉Tweepy：如果触发了Twitter的访问频率限制（Rate Limit），就自动等待，直到限制解除后再继续请求。这能有效避免你的程序因为请求太快而被临时封禁。

4.2 构建智能搜索与解析函数

接下来，我们写一个函数，它的任务是：给定一个搜索词，返回所有找到的视频链接。这里面的门道比想象中要多。

def search_twitter_videos(query, max_tweets=100):
    """
    搜索包含特定关键词的推文，并提取其中的视频链接。

    参数:
        query (str): 搜索关键词，例如 "#cat" 或 "machine learning"。
        max_tweets (int): 想要获取的最大推文数量。

    返回:
        list: 提取到的视频链接列表。
    """
    video_urls = []
    try:
        # 使用API搜索推文，tweet_mode='extended'确保获取全文
        # 注意：search_tweets方法返回的是最近7天的公开推文
        tweets = api.search_tweets(q=query, tweet_mode='extended', count=min(max_tweets, 100))
        
        print(f"搜索关键词 '{query}'，共获取到 {len(tweets)} 条推文。")

        for tweet in tweets:
            # 优先从推文的扩展实体中查找媒体信息（这是最规范的方式）
            if hasattr(tweet, 'extended_entities'):
                media_list = tweet.extended_entities.get('media', [])
                for media in media_list:
                    if media['type'] == 'video' or media['type'] == 'animated_gif':
                        # 视频可能有多个变体（不同分辨率），我们通常取比特率最高的一个
                        variants = media['video_info']['variants']
                        # 筛选出MP4格式的视频流，并按比特率排序
                        mp4_variants = [v for v in variants if v.get('content_type') == 'video/mp4']
                        if mp4_variants:
                            best_video = max(mp4_variants, key=lambda x: x.get('bitrate', 0))
                            video_url = best_video['url']
                            video_urls.append(video_url)
                            print(f"  从推文 {tweet.id} 找到视频: {video_url[:80]}...")
                            continue  # 如果从实体中找到，就跳过下面的HTML解析

            # 方法二：如果实体中没有，尝试从推文全文的HTML中解析（备用方案）
            # 有些第三方客户端或旧格式的视频可能不包含在标准实体中
            try:
                full_text = tweet.full_text
                # 使用BeautifulSoup查找视频标签（常见于某些嵌入格式）
                soup = BeautifulSoup(full_text, 'html.parser')
                video_tags = soup.find_all('video')
                for tag in video_tags:
                    src = tag.get('src')
                    if src and src.startswith('http'):
                        video_urls.append(src)
                        print(f"  从HTML解析到视频: {src[:80]}...")
            except Exception as e:
                # 如果解析出错，记录并跳过这条推文
                print(f"  解析推文 {tweet.id} 的HTML时出错: {e}")
                pass

    except tweepy.TweepyException as e:
        print(f"调用Twitter API时发生错误: {e}")
    except Exception as e:
        print(f"发生未知错误: {e}")

    return video_urls

这个函数是工具的核心。我采用了“两步走”的策略来最大化成功率：

1. 首选方案（规范路径）：直接从Twitter API返回的推文对象中的 extended_entities 字段查找 media。如果媒体类型是 video 或 animated_gif，就进一步从 video_info 里获取不同清晰度的视频流地址，并选择比特率最高的MP4链接。这是最直接、最可靠的方法。
2. 备用方案（兼容路径）：有些推文（特别是包含第三方播放器或特定历史格式的）可能不会在标准实体中提供视频信息。这时，我们使用BeautifulSoup解析推文的全文HTML，寻找 <video> 标签来获取链接。这提高了工具的兼容性。

4.3 让脚本真正跑起来

函数写好了，我们写一个主程序来调用它，并把结果保存下来。

def main():
    # 你想要搜索的关键词
    search_query = "#technology"  # 可以换成任何你感兴趣的话题，比如“#python”, “奥运会”
    # 想要获取的最大推文数（实际可能受API限制）
    max_results = 50

    print("开始搜索Twitter视频...")
    links = search_twitter_videos(search_query, max_results)

    print(f"\n搜索完成！共找到 {len(links)} 个视频链接。")
    
    # 将链接保存到文本文件
    if links:
        filename = f"twitter_videos_{search_query.replace('#', '').replace(' ', '_')}.txt"
        with open(filename, 'w', encoding='utf-8') as f:
            for link in links:
                f.write(link + '\n')
        print(f"所有链接已保存到文件: {filename}")
        
        # 同时在控制台打印前5个链接作为预览
        print("\n预览前5个链接:")
        for i, link in enumerate(links[:5]):
            print(f"  {i+1}. {link}")
    else:
        print("未找到任何视频链接。")

if __name__ == "__main__":
    main()

运行这个脚本，你就能看到控制台开始打印搜索进度，最终会把找到的所有视频链接保存到一个以搜索词命名的 .txt 文件里。你可以用任何文本编辑器打开它，里面就是一排排可以直接访问或用于下载的视频地址。

5. 应对反爬与提升稳定性

直接用上面的基础脚本，对于小规模的、偶尔的抓取是没问题的。但如果你想长时间、大批量地运行，很快就会遇到问题：IP被限制、请求被拒绝。别担心，这是所有爬虫都会遇到的挑战，我们有成熟的策略来应对。

5.1 理解并遵守频率限制

Twitter API对每个接口都有严格的“频率限制”。简单说，就是你在一定时间内能请求的次数是有限的。例如，标准搜索接口可能限制每15分钟最多请求180次。我们的代码里已经通过 wait_on_rate_limit=True 实现了自动等待，这是最基本的礼貌。

但除此之外，我们自己在代码逻辑上也要“温柔”一点。一个非常重要的技巧是：在连续的请求之间加入短暂的随机延迟。这模仿了人类浏览的不规律性，能极大降低被系统识别为机器人的风险。

import random
import time

def polite_request():
    """模拟人类操作，在请求间加入随机延迟"""
    # 随机等待1到3秒
    delay = random.uniform(1, 3)
    time.sleep(delay)
    # 你可以在这里放置实际的请求代码，比如调用api.search_tweets

你可以在遍历推文列表的循环中，每处理几条推文就调用一次这个函数。虽然会让总耗时变长，但换来了极高的稳定性，对于自动化任务来说，稳定远比瞬间完成更重要。

5.2 优雅地处理错误与重试

网络世界充满不确定性，请求超时、连接断开、服务器返回错误都是家常便饭。一个健壮的程序必须能处理这些异常，而不是直接崩溃。

我们可以使用一个简单的重试机制，当请求失败时，等待一会儿再试几次。

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_robust_session(retries=3, backoff_factor=0.5):
    """
    创建一个具有重试机制的稳健的Requests会话。
    当遇到5xx服务器错误或网络波动时，会自动重试。
    """
    session = requests.Session()
    retry_strategy = Retry(
        total=retries,
        backoff_factor=backoff_factor, # 重试等待时间 = backoff_factor * (2^(重试次数-1))
        status_forcelist=[500, 502, 503, 504], # 遇到这些HTTP状态码就重试
    )
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    return session

# 使用示例
session = create_robust_session()
# 当你需要直接用Requests库获取某个视频页面时
try:
    response = session.get('某个视频URL', timeout=10)
    response.raise_for_status() # 如果状态码不是200，会抛出异常
    # 处理响应内容...
except requests.exceptions.RequestException as e:
    print(f"请求失败: {e}")

这个 create_robust_session 函数创建了一个自带“盔甲”的Requests会话。它会在遇到服务器内部错误（5xx）时自动重试最多3次，并且每次重试的等待时间会指数级增加（0.5秒，1秒，2秒），避免对服务器造成连续冲击。

5.3 用户代理与请求头管理

当你直接使用Requests去访问视频链接时，你的请求头（Headers）会暴露一些信息。默认的Requests用户代理（User-Agent）很容易被识别。一个简单的优化是，把它伪装成一个常见浏览器的用户代理。

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'
}
response = session.get(video_url, headers=headers, timeout=10)

这个小技巧能让你的请求看起来更像是一个普通用户在浏览器中发起的，而不是一个Python脚本。

6. 高级技巧与性能优化

当你的需求从“偶尔跑一下”变成“持续收集海量数据”时，基础的脚本可能就力不从心了。下面分享几个我实践中总结的高级技巧，能让你的工具速度更快、能力更强。

6.1 使用分页获取更多结果

基础的 api.search_tweets 一次最多返回100条推文。如果你想获取成百上千条，就需要使用“分页”技术。Tweepy的 Cursor 对象让这变得非常简单。

import tweepy

def search_videos_with_cursor(query, max_items=500):
    """使用Cursor分页获取大量推文"""
    video_urls = []
    item_count = 0
    
    # 使用Cursor遍历搜索结果
    for tweet in tweepy.Cursor(api.search_tweets, q=query, tweet_mode='extended').items(max_items):
        item_count += 1
        # 这里可以复用之前解析视频链接的逻辑
        # ... (解析视频链接并添加到video_urls列表) ...
        
        # 每处理50条推文，打印一次进度并短暂休息
        if item_count % 50 == 0:
            print(f"已处理 {item_count} 条推文，当前找到 {len(video_urls)} 个视频。")
            time.sleep(random.uniform(2, 5)) # 处理一批后休息一下
        
        if item_count >= max_items:
            break
            
    return video_urls

Cursor 会自动处理分页令牌，你只需要像遍历一个普通列表一样使用它。同时，我在循环里加入了进度打印和延迟，既方便观察，又符合“礼貌爬虫”的规范。

6.2 多线程加速下载

找到视频链接后，下一步往往是下载它们。如果视频有几百个，逐个下载会非常慢。这时，我们可以用多线程来并发下载，充分利用网络带宽。

注意： 这里指的是下载视频内容本身，而不是调用Twitter API。对API的请求仍然应该保持顺序和延迟，以避免触发限制。

import concurrent.futures
import os

def download_video(url, save_dir='videos'):
    """下载单个视频到指定目录"""
    if not os.path.exists(save_dir):
        os.makedirs(save_dir)
    
    # 从URL中提取一个简单的文件名
    filename = url.split('/')[-1].split('?')[0][:50] + '.mp4' # 简单处理，避免文件名过长
    filepath = os.path.join(save_dir, filename)
    
    session = create_robust_session()
    headers = {'User-Agent': 'Mozilla/5.0...'}
    
    try:
        print(f"开始下载: {filename}")
        response = session.get(url, headers=headers, stream=True, timeout=30)
        response.raise_for_status()
        
        with open(filepath, 'wb') as f:
            for chunk in response.iter_content(chunk_size=8192):
                f.write(chunk)
        print(f"下载完成: {filename}")
        return filepath
    except Exception as e:
        print(f"下载失败 {url}: {e}")
        return None

def batch_download_videos(url_list, max_workers=5):
    """使用线程池批量下载视频"""
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交所有下载任务
        future_to_url = {executor.submit(download_video, url): url for url in url_list}
        
        for future in concurrent.futures.as_completed(future_to_url):
            url = future_to_url[future]
            try:
                result = future.result()
                if result:
                    print(f"成功: {url} -> {result}")
            except Exception as exc:
                print(f'{url} 下载过程中产生异常: {exc}')

ThreadPoolExecutor 创建了一个线程池，max_workers=5 表示同时最多有5个下载任务在进行。这比一个一个下载快多了。你需要根据你的网络情况和目标服务器的承受能力来调整这个数字。

6.3 数据存储与去重

随着脚本多次运行，你可能会收集到重复的视频链接。一个简单的去重方法是在保存前检查。更专业的做法是使用数据库。这里我展示一个使用轻量级SQLite数据库的例子，它不需要安装额外的服务。

import sqlite3
import hashlib

def init_database(db_path='twitter_videos.db'):
    """初始化数据库，创建表"""
    conn = sqlite3.connect(db_path)
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS videos
                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
                  query TEXT,
                  tweet_id TEXT,
                  video_url TEXT UNIQUE, -- UNIQUE约束确保链接不重复
                  downloaded INTEGER DEFAULT 0,
                  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)''')
    conn.commit()
    conn.close()

def save_links_to_db(video_urls, search_query):
    """将视频链接存入数据库，自动去重"""
    conn = sqlite3.connect('twitter_videos.db')
    c = conn.cursor()
    new_count = 0
    for url in video_urls:
        try:
            # 插入数据，如果url已存在（UNIQUE冲突），则忽略
            c.execute("INSERT OR IGNORE INTO videos (query, video_url) VALUES (?, ?)", 
                     (search_query, url))
            if c.rowcount == 1: # rowcount为1表示插入了新行
                new_count += 1
        except sqlite3.Error as e:
            print(f"数据库错误: {e}")
    conn.commit()
    conn.close()
    print(f"数据库操作完成。尝试插入 {len(video_urls)} 条，其中 {new_count} 条是新链接。")

使用数据库后，你可以轻松地管理历史数据，查询哪些视频已下载，甚至基于推文ID进行更复杂的去重和分析。这为你的项目从“脚本”升级为“系统”打下了基础。

7. 实战：构建一个完整的命令行工具

把上面的所有模块组合起来，我们可以打造一个更友好、更强大的命令行工具。这样，你可以在终端里直接运行它，并传递不同的参数。

# twitter_video_tool.py
import argparse
# ... 其他导入 ...

def main():
    parser = argparse.ArgumentParser(description='Twitter视频链接抓取工具')
    parser.add_argument('-q', '--query', required=True, help='搜索关键词，例如 "#cat"')
    parser.add_argument('-n', '--number', type=int, default=100, help='最大抓取推文数 (默认: 100)')
    parser.add_argument('-o', '--output', default='links.txt', help='输出文件名 (默认: links.txt)')
    parser.add_argument('-d', '--download', action='store_true', help='找到链接后自动下载视频')
    parser.add_argument('--db', action='store_true', help='将结果保存到SQLite数据库')

    args = parser.parse_args()

    print(f"开始搜索: {args.query}")
    video_links = search_twitter_videos(args.query, args.number)

    if args.db:
        save_links_to_db(video_links, args.query)
        print("结果已保存至数据库。")
    else:
        with open(args.output, 'w', encoding='utf-8') as f:
            for link in video_links:
                f.write(link + '\n')
        print(f"链接已保存至文件: {args.output}")

    if args.download and video_links:
        print("开始批量下载视频...")
        batch_download_videos(video_links)
        print("批量下载任务已提交。")

if __name__ == "__main__":
    main()

现在，你可以在命令行里这样使用你的工具了：

# 基础搜索，保存链接到文件
python twitter_video_tool.py -q "#python" -n 200 -o python_videos.txt

# 搜索并自动下载视频
python twitter_video_tool.py -q "machine learning" --download

# 搜索并将结果存入数据库
python twitter_video_tool.py -q "#news" --db

这个工具已经具备了相当的实用性。你可以把它设置成定时任务（比如用cron或Windows任务计划程序），让它每天自动收集特定话题的视频链接，为你的分析项目提供源源不断的数据。

8. 常见问题与排查指南

即使代码写得再完善，在实际运行中还是会遇到各种稀奇古怪的问题。这里我列出几个最常见的问题和解决方法，希望能帮你快速排雷。

问题一：运行脚本时报错 tweepy.error.TweepError: [{'code': 89, 'message': 'Invalid or expired token.'}]

• 原因：这几乎总是因为你的API密钥或访问令牌错误、失效或没有正确的权限。
• 解决：
  1. 仔细检查 CONSUMER_KEY, CONSUMER_SECRET, ACCESS_TOKEN, ACCESS_TOKEN_SECRET 这四个字符串是否完全正确，包括大小写，前后有没有多余的空格。
  2. 去Twitter开发者门户，确认你的App是否处于“Active”状态。
  3. 检查你申请API时选择的权限级别。标准搜索接口需要“Read”权限。如果你需要获取用户时间线等，可能需要“Read and Write”甚至更高。

问题二：只能抓到很少的推文，或者抓不到视频。

• 原因A：你使用的 api.search_tweets 接口默认只返回最近7天的推文。如果你的关键词在过去7天不活跃，结果自然就少。
• 解决A：如果需要历史数据，你需要申请Twitter的“Academic Research”级别的API访问权限，它允许获取完整的历史推文存档。但普通开发者账号目前只有7天。
• 原因B：推文本身可能不包含 extended_entities。有些视频是链接到YouTube、Vimeo等外部网站的，或者是以“卡片”形式展示，这些情况API可能不会直接返回视频流。
• 解决B：这就是为什么我在代码中加入了BeautifulSoup解析作为备用方案。对于外部链接，你可能需要进一步访问那个链接，再从其页面中解析。这会更复杂，需要针对不同网站写不同的解析器。

问题三：程序运行一段时间后突然卡住或报连接错误。

• 原因：很可能是触发了频率限制，或者遇到了不稳定的网络连接。
• 解决：
  1. 确保你在创建 api 对象时设置了 wait_on_rate_limit=True。
  2. 在循环中增加 time.sleep(random.uniform(1, 3)) 这样的延迟。
  3. 使用我上面提供的 create_robust_session 函数来包装你的网络请求，实现自动重试。
  4. 考虑在代码外层加一个 try...except 块，如果发生不可预知的错误，记录日志并优雅地暂停或重启。

问题四：下载下来的视频文件无法播放。

• 原因：视频链接可能只是一个“播放列表”文件（如M3U8），或者需要特定的请求头才能获取真正的媒体流。
• 解决：用文本编辑器打开下载的文件看看。如果里面是文本（包含很多 .ts 片段链接），那说明你抓取到的是HLS流。你需要使用像 yt-dlp 或 ffmpeg 这样的专业工具来处理这种流媒体。对于简单的MP4直链，我们的下载函数是有效的。

最后，也是最重要的，请务必遵守Twitter的开发者协议和 robots.txt 规则。将你的抓取频率控制在合理范围，不要对服务器造成负担。你的工具是为了提高效率，而不是进行攻击。尊重平台规则，你的自动化之路才能走得长远。