Python金融数据获取实战：yfinance库全面指南

2026-04-29 09:24:52作者：彭桢灵Jeremy

一、基础入门：yfinance库快速上手

1.1 环境准备与安装配置

yfinance是一个非官方的Yahoo! Finance API Python库，提供了简单易用的接口来获取金融市场数据。它建立在pandas和requests库之上，能够以DataFrame格式返回数据，便于后续分析和处理。

要开始使用yfinance，首先需要安装该库。推荐使用pip进行安装：

# 安装yfinance库
pip install yfinance --upgrade

# 安装依赖库（如果尚未安装）
pip install pandas numpy matplotlib

安装完成后，在Python代码中导入yfinance库：

import yfinance as yf

💡 实用技巧：建议定期更新yfinance库，因为雅虎财经API可能会发生变化，库的维护者会及时修复兼容性问题。

1.2 基础查询：获取单只股票数据

yfinance的核心功能是通过Ticker对象获取股票数据。每个Ticker对象代表一只股票，可以获取其市场数据、财务信息等。

# 创建Ticker对象，参数为股票代码
msft = yf.Ticker("MSFT")

# 获取基本信息
print("公司名称:", msft.info['longName'])
print("当前价格:", msft.info['currentPrice'])
print("市值:", msft.info['marketCap'])

# 获取历史市场数据
hist = msft.history(period="1d")  # 获取1天的历史数据
print(hist[['Open', 'High', 'Low', 'Close', 'Volume']])

⚠️ 注意事项：股票代码需要使用雅虎财经支持的格式，通常是交易所代码加上公司代码，例如"AAPL"代表苹果公司在纳斯达克的股票。

1.3 数据结构解析：理解返回结果

yfinance返回的数据主要以pandas DataFrame和字典格式为主，便于数据处理和分析。

import yfinance as yf
import pandas as pd

# 获取苹果公司股票数据
aapl = yf.Ticker("AAPL")

# 获取历史数据，返回DataFrame
hist = aapl.history(period="1mo")  # 获取1个月的历史数据
print("数据类型:", type(hist))
print("数据形状:", hist.shape)
print("列名:", hist.columns.tolist())

# 查看前5行数据
print(hist.head())

# 获取公司信息，返回字典
info = aapl.info
print("信息类型:", type(info))
print("可用信息键:", list(info.keys())[:10])  # 打印前10个键

📌 重点：DataFrame是pandas库中的表格型数据结构，类似于Excel表格，非常适合进行数据处理和分析。通过列名可以轻松访问特定数据列，如hist['Close']可以获取收盘价数据。

二、核心功能：yfinance高级应用

2.1 批量股票数据获取

当需要分析多只股票时，yfinance提供了便捷的批量获取功能，避免了多次单独请求的麻烦。

import yfinance as yf
import pandas as pd

# 定义要获取的股票代码列表
tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "META"]

# 批量获取股票数据
data = yf.download(tickers, period="1d", group_by="ticker")

# 查看数据结构
print("数据形状:", data.shape)
print("层级列名:", data.columns)

# 提取单只股票数据
aapl_data = data["AAPL"]
print(aapl_data[['Open', 'Close']])

# 计算简单收益率
returns = data.xs('Close', level=1, axis=1).pct_change()
print("股票收益率:\n", returns)

💡 实用技巧：使用group_by="ticker"参数可以将不同股票的数据组织在多层索引的DataFrame中，便于按股票代码提取数据。

2.2 历史数据下载与存储

获取历史数据是金融分析的基础，yfinance支持灵活的时间范围和频率设置。

import yfinance as yf
import pandas as pd

# 获取特斯拉股票的历史数据
tsla = yf.Ticker("TSLA")

# 方法1: 使用period参数（预定义时间范围）
hist_1y = tsla.history(period="1y", interval="1d")  # 1年的日数据

# 方法2: 使用start和end参数（自定义时间范围）
hist_custom = tsla.history(start="2020-01-01", end="2023-01-01", interval="1wk")  # 周数据

# 查看数据
print("1年日数据形状:", hist_1y.shape)
print("自定义周数据形状:", hist_custom.shape)

# 保存数据到CSV文件
hist_1y.to_csv("tsla_1y_daily.csv")
print("数据已保存到CSV文件")

# 从CSV文件读取数据
df_from_csv = pd.read_csv("tsla_1y_daily.csv", index_col=0, parse_dates=True)
print("从CSV读取的数据:\n", df_from_csv.head())

⚠️ 注意事项：yfinance对数据获取有一定限制，过于频繁的请求可能会被暂时阻止。建议合理设置请求频率，避免短时间内大量请求。

2.3 财务报表与基本面数据

除了市场数据，yfinance还提供了获取公司财务报表的功能，包括资产负债表、利润表和现金流量表。

import yfinance as yf

# 获取微软公司数据
msft = yf.Ticker("MSFT")

# 获取资产负债表
balance_sheet = msft.balance_sheet
print("资产负债表:\n", balance_sheet.head())

# 获取利润表
income_stmt = msft.financials
print("\n利润表:\n", income_stmt.head())

# 获取现金流量表
cash_flow = msft.cashflow
print("\n现金流量表:\n", cash_flow.head())

# 获取季度财务报表
quarterly_income = msft.quarterly_financials
print("\n季度利润表:\n", quarterly_income.head())

# 获取主要财务指标
financial_ratios = msft.info
key_ratios = {
    '市盈率': financial_ratios.get('trailingPE'),
    '市净率': financial_ratios.get('priceToBook'),
    '股息率': financial_ratios.get('dividendYield'),
    '营收增长率': financial_ratios.get('revenueGrowth')
}
print("\n主要财务指标:", key_ratios)

📌 重点：财务报表数据的列索引是会计期间，行索引是财务科目。由于不同公司的会计年度结束时间可能不同，比较时需要注意时间的一致性。

三、数据清洗与预处理

3.1 缺失值处理策略

金融数据中经常会出现缺失值，需要进行适当处理以确保分析的准确性。

import yfinance as yf
import pandas as pd
import numpy as np

# 获取亚马逊股票数据
amzn = yf.Ticker("AMZN")
hist = amzn.history(period="5y", interval="1d")

# 检查缺失值
print("缺失值统计:\n", hist.isnull().sum())

# 方法1: 删除包含缺失值的行
hist_dropna = hist.dropna()
print("删除缺失值后的数据形状:", hist_dropna.shape)

# 方法2: 前向填充
hist_ffill = hist.fillna(method='ffill')
print("前向填充后缺失值统计:\n", hist_ffill.isnull().sum())

# 方法3: 插值法填充
hist_interpolate = hist.interpolate(method='time')
print("插值填充后缺失值统计:\n", hist_interpolate.isnull().sum())

# 比较不同填充方法对收盘价的影响
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 6))
plt.plot(hist['Close'], label='原始数据', alpha=0.3)
plt.plot(hist_ffill['Close'], label='前向填充')
plt.plot(hist_interpolate['Close'], label='插值填充')
plt.title('不同缺失值处理方法对比')
plt.legend()
plt.show()

💡 实用技巧：对于股票价格数据，前向填充（ffill）通常是一个合理的选择，因为价格具有连续性，缺失时刻的价格可以认为与前一时刻相同。

3.2 数据标准化与归一化

在比较不同股票或不同时间范围的数据时，数据标准化和归一化非常重要。

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# 获取多只科技股数据
tickers = ["AAPL", "MSFT", "GOOGL", "AMZN"]
data = yf.download(tickers, period="1y", interval="1d")['Close']

# 方法1: 价格归一化（起始价格=1）
normalized = data / data.iloc[0]
plt.figure(figsize=(12, 6))
normalized.plot()
plt.title('归一化股价走势（起始价格=1）')
plt.ylabel('归一化价格')
plt.show()

# 方法2: 标准化（Z-score标准化）
standardized = (data - data.mean()) / data.std()
plt.figure(figsize=(12, 6))
standardized.plot()
plt.title('标准化股价（Z-score）')
plt.ylabel('标准化值')
plt.show()

# 计算收益率并标准化
returns = data.pct_change().dropna()
returns_standardized = (returns - returns.mean()) / returns.std()
plt.figure(figsize=(12, 6))
returns_standardized.plot(alpha=0.7)
plt.title('标准化收益率')
plt.ylabel('标准化收益率')
plt.show()

⚠️ 注意事项：归一化和标准化是不同的概念。归一化通常将数据缩放到[0,1]范围，而标准化则将数据转换为均值为0、标准差为1的分布。选择哪种方法取决于具体的分析需求。

3.3 时间序列数据处理

金融数据本质上是时间序列数据，需要特殊的处理方法。

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# 获取黄金ETF数据
gld = yf.Ticker("GLD")
hist = gld.history(period="5y", interval="1d")
hist = hist[['Open', 'High', 'Low', 'Close', 'Volume']]

# 时间序列索引处理
print("索引类型:", type(hist.index))
print("日期范围:", hist.index.min(), "至", hist.index.max())

# 重采样到周数据
weekly_data = hist.resample('W').agg({
    'Open': 'first',
    'High': 'max',
    'Low': 'min',
    'Close': 'last',
    'Volume': 'sum'
})
print("周数据形状:", weekly_data.shape)

# 计算移动平均线
hist['MA50'] = hist['Close'].rolling(window=50).mean()
hist['MA200'] = hist['Close'].rolling(window=200).mean()

# 绘制价格和移动平均线
plt.figure(figsize=(12, 6))
plt.plot(hist['Close'], label='收盘价')
plt.plot(hist['MA50'], label='50日移动平均线')
plt.plot(hist['MA200'], label='200日移动平均线')
plt.title('黄金ETF价格与移动平均线')
plt.legend()
plt.show()

# 计算日收益率和累积收益率
hist['Return'] = hist['Close'].pct_change()
hist['CumulativeReturn'] = (1 + hist['Return']).cumprod() - 1
print("累积收益率:", hist['CumulativeReturn'].iloc[-1])

📌 重点：时间序列重采样是将高频率数据转换为低频率数据的过程，例如将日数据转换为周数据。在重采样时，需要为不同的列选择合适的聚合函数，如开盘价用第一个值，最高价用最大值等。

四、实战应用：yfinance在金融分析中的应用

4.1 投资组合分析与评估

yfinance可以帮助投资者分析和评估投资组合的表现。

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 定义投资组合
portfolio = {
    "AAPL": 0.3,   # 苹果公司，占比30%
    "MSFT": 0.25,  # 微软公司，占比25%
    "GOOG": 0.2,   # 谷歌公司，占比20%
    "AMZN": 0.15,  # 亚马逊公司，占比15%
    "TSLA": 0.1    # 特斯拉公司，占比10%
}

# 获取投资组合中所有股票的历史数据
tickers = list(portfolio.keys())
data = yf.download(tickers, period="3y", interval="1d")['Close']

# 计算投资组合的每日收益率
weights = np.array(list(portfolio.values()))
returns = data.pct_change().dropna()
portfolio_returns = returns.dot(weights)

# 计算累积收益率
cumulative_returns = (1 + portfolio_returns).cumprod() - 1

# 绘制投资组合累积收益率
plt.figure(figsize=(12, 6))
cumulative_returns.plot()
plt.title('投资组合累积收益率')
plt.ylabel('累积收益率')
plt.grid(True)
plt.show()

# 计算投资组合的关键指标
total_return = cumulative_returns.iloc[-1]
annualized_return = (1 + total_return) ** (252/len(cumulative_returns)) - 1
volatility = portfolio_returns.std() * np.sqrt(252)
sharpe_ratio = annualized_return / volatility  # 假设无风险利率为0

print(f"总收益率: {total_return:.2%}")
print(f"年化收益率: {annualized_return:.2%}")
print(f"年化波动率: {volatility:.2%}")
print(f"夏普比率: {sharpe_ratio:.2f}")

💡 实用技巧：夏普比率（Sharpe Ratio）是衡量投资组合风险调整后收益的重要指标，数值越高表示单位风险所获得的超额收益越高。一般来说，夏普比率大于1被认为是不错的，大于2则表现优秀。

4.2 技术指标计算与应用

技术指标是股票分析的重要工具，yfinance结合TA-Lib库可以计算各种常用技术指标。

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
# 需要安装TA-Lib: pip install TA-Lib
import talib as ta

# 获取股票数据
ticker = "AAPL"
data = yf.download(ticker, period="2y", interval="1d")

# 计算MACD指标
data['MACD'], data['MACD_signal'], data['MACD_hist'] = ta.MACD(
    data['Close'], fastperiod=12, slowperiod=26, signalperiod=9)

# 计算RSI指标
data['RSI'] = ta.RSI(data['Close'], timeperiod=14)

# 计算布林带
data['BB_upper'], data['BB_middle'], data['BB_lower'] = ta.BBANDS(
    data['Close'], timeperiod=20, nbdevup=2, nbdevdn=2, matype=0)

# 绘制价格和MACD
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(12, 15), sharex=True)

# 价格和布林带
ax1.plot(data['Close'], label='收盘价')
ax1.plot(data['BB_upper'], 'r--', label='布林带上轨')
ax1.plot(data['BB_middle'], 'b--', label='布林带中轨')
ax1.plot(data['BB_lower'], 'g--', label='布林带下轨')
ax1.set_title(f'{ticker} 价格与布林带')
ax1.legend()

# MACD
ax2.plot(data['MACD'], label='MACD')
ax2.plot(data['MACD_signal'], label='信号线')
ax2.bar(data.index, data['MACD_hist'], label='MACD柱状图')
ax2.set_title('MACD指标')
ax2.legend()

# RSI
ax3.plot(data['RSI'], label='RSI')
ax3.axhline(70, color='r', linestyle='--')  # 超买线
ax3.axhline(30, color='g', linestyle='--')  # 超卖线
ax3.set_title('RSI指标')
ax3.legend()

plt.tight_layout()
plt.show()

⚠️ 注意事项：技术指标不是预测市场的绝对工具，而是辅助分析的手段。不同指标可能发出相互矛盾的信号，需要结合多种因素进行综合判断。

4.3 金融数据可视化

数据可视化是理解和展示金融数据的重要方式，matplotlib和seaborn库可以创建丰富的可视化图表。

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# 获取多只股票数据
tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "TSLA"]
data = yf.download(tickers, period="1y", interval="1d")['Close']

# 1. 价格走势比较
plt.figure(figsize=(12, 6))
for ticker in tickers:
    plt.plot(data[ticker], label=ticker)
plt.title('科技股价格走势比较')
plt.ylabel('价格 (USD)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 2. 收益率相关性热图
returns = data.pct_change().dropna()
corr_matrix = returns.corr()

plt.figure(figsize=(10, 8))
sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', vmin=-1, vmax=1)
plt.title('股票收益率相关性热图')
plt.show()

# 3. 成交量与价格关系
aapl = yf.Ticker("AAPL")
aapl_data = aapl.history(period="3mo", interval="1d")

fig, ax1 = plt.subplots(figsize=(12, 6))
ax2 = ax1.twinx()

ax1.plot(aapl_data['Close'], 'b-', label='收盘价')
ax2.bar(aapl_data.index, aapl_data['Volume'], alpha=0.3, color='g', label='成交量')

ax1.set_xlabel('日期')
ax1.set_ylabel('收盘价 (USD)', color='b')
ax2.set_ylabel('成交量', color='g')

plt.title('苹果股票价格与成交量关系')
ax1.legend(loc='upper left')
ax2.legend(loc='upper right')
plt.show()

# 4. 收益率分布直方图
plt.figure(figsize=(12, 6))
for ticker in tickers:
    sns.histplot(returns[ticker], kde=True, bins=50, alpha=0.5, label=ticker)
plt.title('股票日收益率分布')
plt.xlabel('收益率')
plt.ylabel('频率')
plt.legend()
plt.show()

📌 重点：相关性热图可以帮助识别股票之间的相关性，高度相关的股票往往会一起上涨或下跌，这对投资组合多元化很重要。理想的投资组合应包含相关性较低的资产，以分散风险。

五、优化进阶：提升yfinance使用效率

5.1 性能优化技巧

当处理大量数据或频繁获取数据时，性能优化变得尤为重要。

import yfinance as yf
import time
import pandas as pd

# 1. 批量获取vs单个获取性能比较
tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "TSLA", "NVDA", "JPM", "BABA", "PDD"]

# 单个获取
start_time = time.time()
data_single = {}
for ticker in tickers:
    data_single[ticker] = yf.Ticker(ticker).history(period="1y")
single_time = time.time() - start_time
print(f"单个获取耗时: {single_time:.2f}秒")

# 批量获取
start_time = time.time()
data_batch = yf.download(tickers, period="1y", group_by="ticker")
batch_time = time.time() - start_time
print(f"批量获取耗时: {batch_time:.2f}秒")
print(f"批量获取提速: {single_time/batch_time:.2f}倍")

# 2. 数据缓存策略
def get_cached_data(ticker, period="1y", cache_dir="data_cache"):
    """带缓存的数据获取函数"""
    import os
    import pickle
    os.makedirs(cache_dir, exist_ok=True)
    cache_file = os.path.join(cache_dir, f"{ticker}_{period}.pkl")
    
    # 检查缓存是否存在且不过期（1小时有效期）
    if os.path.exists(cache_file):
        modified_time = os.path.getmtime(cache_file)
        if time.time() - modified_time < 3600:  # 1小时 = 3600秒
            with open(cache_file, 'rb') as f:
                return pickle.load(f)
    
    # 缓存不存在或已过期，重新获取数据
    data = yf.Ticker(ticker).history(period=period)
    
    # 保存到缓存
    with open(cache_file, 'wb') as f:
        pickle.dump(data, f)
    
    return data

# 使用缓存获取数据
start_time = time.time()
data_cached = get_cached_data("AAPL", "1y")
cache_time = time.time() - start_time
print(f"首次获取耗时: {cache_time:.2f}秒")

start_time = time.time()
data_cached_again = get_cached_data("AAPL", "1y")
cache_again_time = time.time() - start_time
print(f"缓存获取耗时: {cache_again_time:.2f}秒")
print(f"缓存提速: {cache_time/cache_again_time:.2f}倍")

💡 实用技巧：批量获取数据比单个获取效率高得多，特别是当需要获取多只股票数据时。此外，实现数据缓存机制可以避免重复获取相同数据，显著提高应用性能。

5.2 异步数据获取

使用异步编程可以进一步提高数据获取效率，特别是在需要获取大量数据时。

import asyncio
import aiohttp
import yfinance as yf
import pandas as pd
from concurrent.futures import ThreadPoolExecutor

# 使用线程池实现并行获取
def fetch_ticker_data(ticker):
    """获取单个股票数据的函数"""
    try:
        ticker_obj = yf.Ticker(ticker)
        return ticker, ticker_obj.history(period="1y")
    except Exception as e:
        print(f"获取{ticker}数据失败: {e}")
        return ticker, None

def parallel_fetch(tickers, max_workers=5):
    """并行获取多个股票数据"""
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        results = executor.map(fetch_ticker_data, tickers)
    
    # 整理结果
    data = {}
    for ticker, df in results:
        if df is not None:
            data[ticker] = df
    return data

# 测试并行获取性能
tickers = ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "TSLA", 
           "NVDA", "JPM", "BABA", "PDD", "NFLX", "DIS", "INTC", "CSCO", "ADBE"]

start_time = time.time()
data_parallel = parallel_fetch(tickers, max_workers=5)
parallel_time = time.time() - start_time
print(f"并行获取{len(tickers)}只股票数据耗时: {parallel_time:.2f}秒")
print(f"成功获取{len(data_parallel)}只股票数据")

# 使用异步HTTP请求获取数据（更高级的方法）
async def async_yfinance_download(session, ticker, period="1y"):
    """异步获取股票数据"""
    url = f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}?period1=0&period2=9999999999&interval=1d&events=history"
    async with session.get(url) as response:
        if response.status == 200:
            data = await response.json()
            # 这里需要解析JSON数据，转换为DataFrame
            # 简化示例，实际实现需要更复杂的解析
            return ticker, True
        else:
            return ticker, False

async def async_batch_fetch(tickers):
    """异步批量获取股票数据"""
    async with aiohttp.ClientSession() as session:
        tasks = [async_yfinance_download(session, ticker) for ticker in tickers]
        results = await asyncio.gather(*tasks)
    return results

# 运行异步获取
start_time = time.time()
loop = asyncio.get_event_loop()
async_results = loop.run_until_complete(async_batch_fetch(tickers))
async_time = time.time() - start_time
print(f"异步获取{len(tickers)}只股票数据耗时: {async_time:.2f}秒")

⚠️ 注意事项：并行和异步获取可以提高效率，但也会增加服务器负担。请合理设置并发数量，避免过于频繁的请求导致IP被暂时封禁。

5.3 量化策略回测基础

yfinance获取的历史数据可用于量化策略的回测，评估策略的历史表现。

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# 定义一个简单的移动平均线交叉策略
def moving_average_strategy(data, short_window=50, long_window=200):
    """
    移动平均线交叉策略:
    - 当短期均线上穿长期均线时买入
    - 当短期均线下穿长期均线时卖出
    """
    # 计算移动平均线
    data['short_ma'] = data['Close'].rolling(window=short_window).mean()
    data['long_ma'] = data['Close'].rolling(window=long_window).mean()
    
    # 生成交易信号
    data['signal'] = 0  # 0表示无信号，1表示买入，-1表示卖出
    data['signal'][short_window:] = np.where(
        data['short_ma'][short_window:] > data['long_ma'][short_window:], 1, 0)
    data['position'] = data['signal'].diff()  # 计算持仓变化
    
    return data

# 获取回测数据
ticker = "AAPL"
data = yf.download(ticker, period="10y", interval="1d")
data = moving_average_strategy(data)

# 计算策略收益
data['return'] = data['Close'].pct_change()
data['strategy_return'] = data['return'] * data['signal'].shift(1)  # 信号滞后一天执行

# 计算累积收益
data['cumulative_market'] = (1 + data['return']).cumprod() - 1
data['cumulative_strategy'] = (1 + data['strategy_return']).cumprod() - 1

# 绘制策略表现
plt.figure(figsize=(12, 6))
plt.plot(data['cumulative_market'], label='市场收益')
plt.plot(data['cumulative_strategy'], label='策略收益')
plt.title(f'{ticker} 移动平均线交叉策略回测')
plt.ylabel('累积收益率')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

# 计算策略评价指标
total_days = len(data)
win_rate = (data['strategy_return'] > 0).sum() / (data['strategy_return'] != 0).sum()
total_return = data['cumulative_strategy'].iloc[-1]
annualized_return = (1 + total_return) ** (252/total_days) - 1
volatility = data['strategy_return'].std() * np.sqrt(252)
sharpe_ratio = annualized_return / volatility

print(f"总收益率: {total_return:.2%}")
print(f"年化收益率: {annualized_return:.2%}")
print(f"年化波动率: {volatility:.2%}")
print(f"夏普比率: {sharpe_ratio:.2f}")
print(f"胜率: {win_rate:.2%}")

📌 重点：回测结果不代表未来表现。历史表现良好的策略在未来可能因为市场结构变化、交易成本等因素而表现不佳。在实际应用中，需要考虑交易成本、滑点、流动性等实际因素。

六、常见问题与解决方案

6.1 数据获取问题及解决方法

在使用yfinance过程中，可能会遇到各种数据获取问题，以下是常见问题及解决方法。

import yfinance as yf
import pandas as pd

# 1. 解决"远程服务器强制关闭连接"问题
def safe_download(tickers, period="1d", retries=3):
    """带重试机制的数据下载函数"""
    for i in range(retries):
        try:
            data = yf.download(tickers, period=period)
            return data
        except Exception as e:
            print(f"下载失败，第{i+1}次重试: {e}")
            if i < retries - 1:
                import time
                time.sleep(2 ** i)  # 指数退避策略
    return None

# 使用安全下载函数
data = safe_download(["AAPL", "MSFT"], period="1y", retries=3)
if data is not None:
    print("数据下载成功:", data.shape)
else:
    print("数据下载失败")

# 2. 处理不同市场的股票代码
def get_global_ticker(country, symbol):
    """获取不同国家/地区的股票代码格式"""
    country_codes = {
        'us': '',          # 美国市场，无需后缀
        'hk': '.HK',       # 香港市场
        'jp': '.T',        # 日本市场
        'cn': '.SS',       # 上海证券交易所
        'cn_sz': '.SZ',    # 深圳证券交易所
        'de': '.DE',       # 德国市场
        'uk': '.L'         # 英国市场
    }
    return symbol + country_codes.get(country.lower(), '')

# 获取不同市场的股票数据
tickers = {
    '美国-苹果': get_global_ticker('us', 'AAPL'),
    '香港-腾讯': get_global_ticker('hk', '00700'),
    '日本-丰田': get_global_ticker('jp', '7203'),
    '中国-茅台': get_global_ticker('cn', '600519')
}

for name, ticker in tickers.items():
    try:
        data = yf.Ticker(ticker).history(period="1mo")
        print(f"{name} ({ticker}) 数据获取成功: {len(data)}条记录")
    except Exception as e:
        print(f"{name} ({ticker}) 数据获取失败: {e}")

# 3. 处理数据不完整问题
def complete_data(data):
    """处理不完整的时间序列数据"""
    # 确保索引是DatetimeIndex
    if not isinstance(data.index, pd.DatetimeIndex):
        data.index = pd.to_datetime(data.index)
    
    # 创建完整的日期范围
    full_index = pd.date_range(start=data.index.min(), end=data.index.max(), freq='B')
    
    # 重新索引并填充缺失值
    data_complete = data.reindex(full_index)
    
    # 填充缺失值（前向填充）
    data_complete = data_complete.fillna(method='ffill')
    
    return data_complete

# 测试数据补全功能
aapl = yf.Ticker("AAPL")
data = aapl.history(period="1mo")
print("原始数据形状:", data.shape)

data_complete = complete_data(data)
print("补全后数据形状:", data_complete.shape)
print("缺失值数量:", data_complete.isnull().sum().sum())

💡 实用技巧：当获取国际市场股票数据时，需要使用正确的股票代码格式。不同国家和地区的股票代码通常需要添加特定的后缀，如香港股票添加".HK"，日本股票添加".T"等。

6.2 金融数据API横向对比分析

除了yfinance，还有其他一些常用的金融数据API，各有优缺点。

# 金融数据API对比分析

"""
常用金融数据API横向对比

1. yfinance
   - 优点: 免费、无需API密钥、使用简单、数据丰富
   - 缺点: 非官方API、稳定性较差、有请求限制、数据延迟约15-20分钟
   - 适用场景: 个人项目、教学、原型开发、非商业用途
   - 数据覆盖: 全球主要市场股票、指数、ETF、加密货币等
   - Python支持: 优秀（专门的yfinance库）

2. Alpha Vantage
   - 优点: 免费计划可用、数据质量高、API稳定、提供技术指标
   - 缺点: 免费计划有请求频率限制（每分钟5次）、部分高级功能需要付费
   - 适用场景: 个人项目、小型应用、需要技术指标的场景
   - 数据覆盖: 股票、指数、外汇、加密货币
   - Python支持: 良好（有第三方库如alpha_vantage）

3. IEX Cloud
   - 优点: 数据实时性高、API稳定、数据质量高
   - 缺点: 免费计划非常有限、付费计划较贵、部分高级数据需额外付费
   - 适用场景: 商业应用、需要实时数据的场景
   - 数据覆盖: 主要是美国市场股票、ETF
   - Python支持: 良好（有第三方库如iexfinance）

4. Quandl
   - 优点: 数据种类丰富、包含大量替代数据、API稳定
   - 缺点: 优质数据大多需要付费、免费数据有限
   - 适用场景: 需要替代数据的量化研究、学术研究
   - 数据覆盖: 股票、期货、期权、宏观经济数据、替代数据
   - Python支持: 优秀（有官方quandl库）

5. Tiingo
   - 优点: 提供免费计划、数据质量高、API设计良好
   - 缺点: 免费计划数据有限、高级功能需要付费
   - 适用场景: 个人项目、小型应用
   - 数据覆盖: 股票、ETF、加密货币
   - Python支持: 良好（有官方tiingo库）
"""

# 选择建议代码示例
def select_finance_api(use_case, budget, data_needs):
    """根据使用场景、预算和数据需求推荐合适的金融数据API"""
    if budget == "free" and use_case in ["personal", "education", "prototype"]:
        if data_needs == "basic":
            return "推荐使用yfinance：免费、无需API密钥、使用简单"
        else:
            return "推荐使用Alpha Vantage：免费计划可用，提供更多技术指标"
    elif budget == "limited" and use_case in ["small_business", "startup"]:
        return "推荐使用IEX Cloud或Tiingo的入门付费计划：平衡了成本和数据质量"
    elif budget == "unlimited" and use_case in ["enterprise", "commercial"]:
        return "推荐使用Bloomberg API或Refinitiv Eikon：提供最全面、最及时的金融数据"
    else:
        return "无法确定最佳API，请提供更多需求信息"

# 测试推荐函数
print(select_finance_api("personal", "free", "basic"))
print(select_finance_api("personal", "free", "advanced"))
print(select_finance_api("small_business", "limited", "advanced"))
print(select_finance_api("enterprise", "unlimited", "comprehensive"))

⚠️ 注意事项：在选择金融数据API时，需要考虑多个因素，包括成本、数据质量、实时性、覆盖范围、API稳定性和使用限制等。对于商业应用，确保遵守API的使用条款，避免违反许可协议。

6.3 实时数据监控系统实现

实时监控股票价格变动对于日内交易和市场监控非常重要。

import yfinance as yf
import time
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# 实时价格监控类
class StockMonitor:
    def __init__(self, tickers, update_interval=5):
        """
        初始化股票监控器
        :param tickers: 要监控的股票代码列表
        :param update_interval: 更新间隔（秒）
        """
        self.tickers = tickers
        self.update_interval = update_interval
        self.price_history = {ticker: pd.DataFrame(columns=['Time', 'Price']) for ticker in tickers}
        
        # 设置图表
        self.fig, self.ax = plt.subplots(figsize=(12, 6))
        self.lines = {ticker: self.ax.plot([], [], label=ticker)[0] for ticker in tickers}
        self.ax.legend()
        self.ax.set_title('实时股票价格监控')
        self.ax.set_xlabel('时间')
        self.ax.set_ylabel('价格 (USD)')
        self.ax.grid(True, alpha=0.3)
    
    def get_current_price(self, ticker):
        """获取股票当前价格"""
        try:
            ticker_obj = yf.Ticker(ticker)
            return ticker_obj.info.get('currentPrice')
        except Exception as e:
            print(f"获取{ticker}价格失败: {e}")
            return None
    
    def update_data(self):
        """更新价格数据"""
        current_time = pd.Timestamp.now()
        for ticker in self.tickers:
            price = self.get_current_price(ticker)
            if price is not None:
                new_row = pd.DataFrame({'Time': [current_time], 'Price': [price]})
                self.price_history[ticker] = pd.concat([self.price_history[ticker], new_row], ignore_index=True)
                # 保留最近100个数据点
                if len(self.price_history[ticker]) > 100:
                    self.price_history[ticker] = self.price_history[ticker].tail(100)
    
    def update_plot(self, frame):
        """更新图表"""
        self.update_data()
        
        # 找到所有数据的时间范围
        all_times = []
        for ticker in self.tickers:
            if not self.price_history[ticker].empty:
                all_times.extend(self.price_history[ticker]['Time'].tolist())
        
        if all_times:
            min_time = min(all_times)
            max_time = max(all_times)
            self.ax.set_xlim(min_time, max_time)
            
            # 更新每条线的数据
            for ticker, line in self.lines.items():
                if not self.price_history[ticker].empty:
                    line.set_data(
                        self.price_history[ticker]['Time'],
                        self.price_history[ticker]['Price']
                    )
            
            # 自动调整y轴范围
            all_prices = []
            for ticker in self.tickers:
                if not self.price_history[ticker].empty:
                    all_prices.extend(self.price_history[ticker]['Price'].tolist())
            if all_prices:
                min_price = min(all_prices) * 0.99
                max_price = max(all_prices) * 1.01
                self.ax.set_ylim(min_price, max_price)
        
        return self.lines.values()
    
    def start_monitoring(self):
        """开始监控"""
        print(f"开始监控股票: {', '.join(self.tickers)}")
        print(f"更新间隔: {self.update_interval}秒")
        print("按Ctrl+C停止监控...")
        
        # 创建动画
        self.ani = FuncAnimation(
            self.fig, self.update_plot, interval=self.update_interval * 1000, blit=True
        )
        
        plt.show()

# 使用示例
if __name__ == "__main__":
    # 监控科技巨头股票
    monitor = StockMonitor(["AAPL", "MSFT", "GOOGL", "AMZN"], update_interval=5)
    try:
        monitor.start_monitoring()
    except KeyboardInterrupt:
        print("\n监控已停止")