首页
/ yfinance数据获取受限问题解决方案与实战指南

yfinance数据获取受限问题解决方案与实战指南

2026-03-09 05:33:53作者：韦蓉瑛
yfinance
Download market data from Yahoo! Finance's API
项目地址：https://gitcode.com/GitHub_Trending/yf/yfinance

摘要

在使用yfinance获取金融市场数据时，开发者常面临访问受限、请求失败等问题。本文系统分析了yfinance使用过程中的各类技术障碍，提供了从问题诊断到解决方案实施的完整流程，并通过实战案例展示了如何构建稳定高效的数据获取系统。无论是处理"429 Too Many Requests"错误，还是解决网络访问限制，本文都提供了可直接落地的技术方案和最佳实践。

一、问题现象与影响范围

1.1 常见错误类型及表现

yfinance用户在数据获取过程中可能遇到多种错误，主要包括：

错误类型 错误信息 发生场景
速率限制 429 Too Many Requests 短时间内发送大量请求
访问权限 403 Forbidden IP被临时封禁或地域限制
连接问题 Connection Timeout 网络不稳定或代理配置错误
数据异常 KeyError或数据不完整 API响应结构变化或解析错误

1.2 业务影响评估

数据获取失败可能导致：

  • 投资决策延迟或错误
  • 回测系统中断
  • 实时监控功能失效
  • 数据分析结果偏差

二、问题定位方法

2.1 系统化诊断流程

  1. 初步检查

    • 验证网络连接状态
    • 确认yfinance版本是否最新
    • 检查基础代码逻辑是否正确

  2. 错误日志分析

    import yfinance as yf
import logging

# 配置详细日志
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

# 尝试获取数据并捕获异常
try:
    ticker = yf.Ticker("AAPL")
    data = ticker.history(period="1d")
    print("数据获取成功")
except Exception as e:
    logging.error(f"数据获取失败: {str(e)}", exc_info=True)

  3. 网络环境测试

    import requests

def test_connection(url="https://finance.yahoo.com"):
    try:
        response = requests.get(url, timeout=10)
        print(f"连接成功，状态码: {response.status_code}")
        return True
    except requests.exceptions.RequestException as e:
        print(f"连接失败: {str(e)}")
        return False

test_connection()

2.2 问题排查决策树

开始
│
├─获取数据是否失败?
│ ├─是→检查错误类型
│ │ ├─429错误→进入速率限制解决方案
│ │ ├─403错误→进入访问权限解决方案
│ │ ├─超时错误→进入网络连接解决方案
│ │ └─其他错误→进入数据解析解决方案
│ │
│ └─否→检查数据质量
│   ├─数据不完整→进入数据修复方案
│   └─数据正常→问题解决

三、解决方案对比与实施

3.1 网络访问优化方案

方案A：全局代理配置

import yfinance as yf
from yfinance import config

# 方法1: 使用set_config设置
yf.set_config({"proxy": "http://your-proxy-server:port"})

# 方法2: 直接修改配置字典
config["proxy"] = "http://your-proxy-server:port"

# 方法3: 使用环境变量
import os
os.environ["HTTP_PROXY"] = "http://your-proxy-server:port"
os.environ["HTTPS_PROXY"] = "https://your-proxy-server:port"

方案B：动态代理池实现

import yfinance as yf
import random

class ProxyManager:
    def __init__(self, proxies):
        self.proxies = proxies
        self.current_proxy_index = 0
        
    def get_next_proxy(self):
        proxy = self.proxies[self.current_proxy_index]
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxies)
        return proxy

# 代理池初始化
proxy_pool = ProxyManager([
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port"
])

# 使用代理池获取数据
def get_data_with_proxy(ticker):
    max_retries = 3
    for _ in range(max_retries):
        try:
            proxy = proxy_pool.get_next_proxy()
            yf.set_config({"proxy": proxy})
            ticker_obj = yf.Ticker(ticker)
            return ticker_obj.history(period="1d")
        except Exception as e:
            print(f"使用代理 {proxy} 失败: {str(e)}")
    raise Exception("所有代理均尝试失败")

方案对比

方案 优点 缺点 适用场景
全局代理 配置简单，无需修改代码 单一代理易被封禁 小规模数据获取
代理池 分散风险，提高稳定性 实现复杂，需维护代理列表 大规模数据获取

3.2 速率限制控制策略

基础版：固定延迟控制

import yfinance as yf
import time
import random

def fetch_data_with_delay(tickers, base_delay=2, random_delay_range=(0, 1)):
    results = {}
    for ticker in tickers:
        try:
            # 随机延迟，避免规律性请求
            delay = base_delay + random.uniform(*random_delay_range)
            time.sleep(delay)
            
            ticker_obj = yf.Ticker(ticker)
            results[ticker] = ticker_obj.history(period="1d")
            print(f"成功获取 {ticker} 数据")
        except Exception as e:
            print(f"获取 {ticker} 失败: {str(e)}")
            results[ticker] = None
    return results

# 使用示例
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]
data = fetch_data_with_delay(tickers)

高级版：自适应速率控制

import yfinance as yf
import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests=10, time_window=60):
        self.max_requests = max_requests
        self.time_window = time_window
        self.request_timestamps = deque()
        
    def wait_if_needed(self):
        now = time.time()
        
        # 移除时间窗口外的请求记录
        while self.request_timestamps and now - self.request_timestamps[0] > self.time_window:
            self.request_timestamps.popleft()
            
        # 如果达到请求上限，计算需要等待的时间
        if len(self.request_timestamps) >= self.max_requests:
            oldest_request = self.request_timestamps[0]
            wait_time = self.time_window - (now - oldest_request) + 1  # 额外加1秒保险
            print(f"达到速率限制，等待 {wait_time:.2f} 秒")
            time.sleep(wait_time)
            
        # 记录当前请求时间
        self.request_timestamps.append(time.time())

# 使用示例
rate_limiter = RateLimiter(max_requests=10, time_window=60)  # 60秒内最多10个请求
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "META", "NVDA", "BABA", "PDD", "NFLX"]
results = {}

for ticker in tickers:
    rate_limiter.wait_if_needed()
    try:
        ticker_obj = yf.Ticker(ticker)
        results[ticker] = ticker_obj.history(period="1d")
        print(f"成功获取 {ticker} 数据")
    except Exception as e:
        print(f"获取 {ticker} 失败: {str(e)}")
        results[ticker] = None

3.3 缓存机制应用

import yfinance as yf
import json
import os
from datetime import datetime, timedelta

class DataCache:
    def __init__(self, cache_dir="yfinance_cache", max_age_hours=24):
        self.cache_dir = cache_dir
        self.max_age_hours = max_age_hours
        os.makedirs(cache_dir, exist_ok=True)
        
    def _get_cache_path(self, ticker, period):
        return os.path.join(self.cache_dir, f"{ticker}_{period}.json")
        
    def is_cache_valid(self, ticker, period):
        cache_path = self._get_cache_path(ticker, period)
        if not os.path.exists(cache_path):
            return False
            
        modified_time = datetime.fromtimestamp(os.path.getmtime(cache_path))
        return datetime.now() - modified_time < timedelta(hours=self.max_age_hours)
        
    def get_cached_data(self, ticker, period):
        if self.is_cache_valid(ticker, period):
            with open(self._get_cache_path(ticker, period), 'r') as f:
                return json.load(f)
        return None
        
    def cache_data(self, ticker, period, data):
        # 将DataFrame转换为可序列化格式
        if hasattr(data, 'to_json'):
            data_json = data.to_json()
        else:
            data_json = json.dumps(data)
            
        with open(self._get_cache_path(ticker, period), 'w') as f:
            f.write(data_json)

# 使用缓存获取数据
cache = DataCache(max_age_hours=6)  # 缓存6小时有效

def get_data_with_cache(ticker, period="1d"):
    # 先尝试从缓存获取
    cached_data = cache.get_cached_data(ticker, period)
    if cached_data:
        print(f"从缓存获取 {ticker} 数据")
        return pd.read_json(json.dumps(cached_data))
        
    # 缓存失效，从API获取
    print(f"从API获取 {ticker} 数据")
    ticker_obj = yf.Ticker(ticker)
    data = ticker_obj.history(period=period)
    
    # 缓存新数据
    cache.cache_data(ticker, period, data)
    return data

四、实战应用案例

4.1 构建稳定的数据获取系统

import yfinance as yf
import time
import pandas as pd
from proxy_manager import ProxyManager  # 假设已实现前面的代理池类
from rate_limiter import RateLimiter  # 假设已实现前面的速率限制类
from data_cache import DataCache  # 假设已实现前面的缓存类

class StableDataFetcher:
    def __init__(self, proxies=None, max_requests=10, time_window=60, cache_age=6):
        self.proxy_manager = ProxyManager(proxies) if proxies else None
        self.rate_limiter = RateLimiter(max_requests, time_window)
        self.cache = DataCache(max_age_hours=cache_age)
        self.retry_count = 3
        
    def fetch_data(self, ticker, period="1d"):
        # 先尝试从缓存获取
        cached_data = self.cache.get_cached_data(ticker, period)
        if cached_data:
            return pd.read_json(json.dumps(cached_data))
            
        # 准备获取新数据
        for attempt in range(self.retry_count):
            try:
                # 速率控制
                self.rate_limiter.wait_if_needed()
                
                # 如有代理池，使用代理
                if self.proxy_manager:
                    proxy = self.proxy_manager.get_next_proxy()
                    yf.set_config({"proxy": proxy})
                    
                # 获取数据
                ticker_obj = yf.Ticker(ticker)
                data = ticker_obj.history(period=period)
                
                # 缓存数据
                self.cache.cache_data(ticker, period, data)
                return data
                
            except Exception as e:
                print(f"尝试 {attempt+1}/{self.retry_count} 获取 {ticker} 失败: {str(e)}")
                if attempt < self.retry_count - 1:
                    # 指数退避策略
                    sleep_time = (2 ** attempt) + random.uniform(0, 1)
                    print(f"将在 {sleep_time:.2f} 秒后重试...")
                    time.sleep(sleep_time)
                    
        raise Exception(f"超过最大重试次数，无法获取 {ticker} 数据")

# 使用示例
proxies = [
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port"
]

fetcher = StableDataFetcher(
    proxies=proxies,
    max_requests=10,  # 每分钟最多10个请求
    time_window=60,
    cache_age=6  # 缓存6小时
)

tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]
results = {}

for ticker in tickers:
    try:
        results[ticker] = fetcher.fetch_data(ticker, period="1wk")
        print(f"成功获取 {ticker} 周数据")
    except Exception as e:
        print(f"获取 {ticker} 失败: {str(e)}")
        results[ticker] = None

4.2 批量数据获取与错误恢复

def batch_fetch_data(fetcher, tickers, batch_size=5, batch_delay=10):
    """
    批量获取数据，包含批次间延迟和错误处理
    
    参数:
        fetcher: StableDataFetcher实例
        tickers: 股票代码列表
        batch_size: 每批处理的股票数量
        batch_delay: 批次间延迟时间(秒)
    """
    results = {}
    failed_tickers = []
    
    # 将股票列表分成批次
    batches = [tickers[i:i+batch_size] for i in range(0, len(tickers), batch_size)]
    
    for i, batch in enumerate(batches):
        print(f"处理第 {i+1}/{len(batches)} 批次，共 {len(batch)} 个股票")
        
        for ticker in batch:
            try:
                results[ticker] = fetcher.fetch_data(ticker)
            except Exception as e:
                print(f"获取 {ticker} 失败: {str(e)}")
                failed_tickers.append(ticker)
        
        # 批次间增加延迟，避免请求过于集中
        if i < len(batches) - 1:
            print(f"批次处理完成，等待 {batch_delay} 秒...")
            time.sleep(batch_delay)
    
    # 重试失败的股票
    if failed_tickers:
        print(f"开始重试 {len(failed_tickers)} 个失败的股票...")
        for ticker in failed_tickers:
            try:
                results[ticker] = fetcher.fetch_data(ticker)
                print(f"重试成功: {ticker}")
            except Exception as e:
                print(f"重试 {ticker} 仍然失败: {str(e)}")
    
    return results

# 使用示例
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "META", "NVDA", "BABA", "PDD", "NFLX"]
results = batch_fetch_data(fetcher, tickers, batch_size=3, batch_delay=15)

五、问题诊断与效果验证

5.1 量化指标监控

import time
import matplotlib.pyplot as plt

class FetchMonitor:
    def __init__(self):
        self.metrics = {
            "success_count": 0,
            "failure_count": 0,
            "total_time": 0,
            "avg_time_per_request": 0,
            "success_rates": [],
            "response_times": []
        }
        self.start_time = None
        
    def start_request(self):
        self.start_time = time.time()
        
    def end_request(self, success=True):
        if self.start_time is None:
            return
            
        duration = time.time() - self.start_time
        
        # 更新指标
        if success:
            self.metrics["success_count"] += 1
        else:
            self.metrics["failure_count"] += 1
            
        self.metrics["total_time"] += duration
        self.metrics["response_times"].append(duration)
        
        # 计算成功率
        total = self.metrics["success_count"] + self.metrics["failure_count"]
        success_rate = self.metrics["success_count"] / total if total > 0 else 0
        self.metrics["success_rates"].append(success_rate)
        
        # 计算平均响应时间
        self.metrics["avg_time_per_request"] = (
            self.metrics["total_time"] / total if total > 0 else 0
        )
        
    def generate_report(self):
        """生成性能报告"""
        total = self.metrics["success_count"] + self.metrics["failure_count"]
        report = {
            "总请求数": total,
            "成功数": self.metrics["success_count"],
            "失败数": self.metrics["failure_count"],
            "成功率": f"{self.metrics['success_count']/total*100:.2f}%" if total > 0 else "0%",
            "总耗时": f"{self.metrics['total_time']:.2f}秒",
            "平均响应时间": f"{self.metrics['avg_time_per_request']:.2f}秒"
        }
        
        # 绘制成功率趋势图
        plt.figure(figsize=(10, 4))
        plt.plot(self.metrics["success_rates"])
        plt.title("请求成功率趋势")
        plt.ylabel("成功率")
        plt.xlabel("请求次数")
        plt.ylim(0, 1.1)
        plt.savefig("success_rate_trend.png")
        
        # 绘制响应时间分布图
        plt.figure(figsize=(10, 4))
        plt.hist(self.metrics["response_times"], bins=20)
        plt.title("响应时间分布")
        plt.xlabel("响应时间(秒)")
        plt.ylabel("请求次数")
        plt.savefig("response_time_distribution.png")
        
        return report

# 使用示例
monitor = FetchMonitor()
fetcher = StableDataFetcher()  # 使用前面定义的稳定数据获取器
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]

for ticker in tickers:
    monitor.start_request()
    try:
        data = fetcher.fetch_data(ticker)
        monitor.end_request(success=True)
        print(f"成功获取 {ticker} 数据")
    except Exception as e:
        monitor.end_request(success=False)
        print(f"获取 {ticker} 失败: {str(e)}")

# 生成并打印报告
report = monitor.generate_report()
print("\n数据获取性能报告:")
for key, value in report.items():
    print(f"{key}: {value}")

5.2 解决方案效果验证方法

  1. A/B测试框架
def ab_test_solution(original_func, optimized_func, tickers, iterations=5):
    """
    对比测试原始方案和优化方案的性能
    
    参数:
        original_func: 原始数据获取函数
        optimized_func: 优化后的数据获取函数
        tickers: 测试用股票列表
        iterations: 测试迭代次数
    """
    import time
    import numpy as np
    
    # 存储测试结果
    original_results = []
    optimized_results = []
    
    print("开始A/B测试...")
    print(f"测试股票数量: {len(tickers)}, 迭代次数: {iterations}")
    
    # 测试原始方案
    print("\n测试原始方案...")
    for i in range(iterations):
        start_time = time.time()
        success_count = 0
        
        for ticker in tickers:
            try:
                original_func(ticker)
                success_count += 1
            except:
                pass
                
        duration = time.time() - start_time
        success_rate = success_count / len(tickers)
        original_results.append({
            "duration": duration,
            "success_rate": success_rate
        })
        print(f"迭代 {i+1}: 耗时 {duration:.2f}秒, 成功率 {success_rate*100:.2f}%")
    
    # 测试优化方案
    print("\n测试优化方案...")
    for i in range(iterations):
        start_time = time.time()
        success_count = 0
        
        for ticker in tickers:
            try:
                optimized_func(ticker)
                success_count += 1
            except:
                pass
                
        duration = time.time() - start_time
        success_rate = success_count / len(tickers)
        optimized_results.append({
            "duration": duration,
            "success_rate": success_rate
        })
        print(f"迭代 {i+1}: 耗时 {duration:.2f}秒, 成功率 {success_rate*100:.2f}%")
    
    # 计算平均结果
    original_avg_duration = np.mean([r["duration"] for r in original_results])
    original_avg_success = np.mean([r["success_rate"] for r in original_results])
    
    optimized_avg_duration = np.mean([r["duration"] for r in optimized_results])
    optimized_avg_success = np.mean([r["success_rate"] for r in optimized_results])
    
    # 输出对比结果
    print("\n=== A/B测试结果对比 ===")
    print(f"原始方案平均耗时: {original_avg_duration:.2f}秒")
    print(f"优化方案平均耗时: {optimized_avg_duration:.2f}秒")
    print(f"耗时改善: {(1 - optimized_avg_duration/original_avg_duration)*100:.2f}%")
    
    print(f"\n原始方案平均成功率: {original_avg_success*100:.2f}%")
    print(f"优化方案平均成功率: {optimized_avg_success*100:.2f}%")
    print(f"成功率提升: {(optimized_avg_success - original_avg_success)*100:.2f}个百分点")

# 使用示例
def original_fetch(ticker):
    """原始数据获取方法"""
    ticker_obj = yf.Ticker(ticker)
    return ticker_obj.history(period="1d")

def optimized_fetch(ticker):
    """优化后的数据获取方法"""
    return fetcher.fetch_data(ticker)  # 使用前面定义的StableDataFetcher

# 运行A/B测试
test_tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA", "META", "NVDA", "BABA"]
ab_test_solution(original_fetch, optimized_fetch, test_tickers, iterations=3)

六、常见误区解析

6.1 配置相关误区

  1. 代理配置不完全

    • 误区：仅设置HTTP代理而忽略HTTPS代理
    • 正确做法：同时配置HTTP和HTTPS代理，确保所有请求都通过代理发送

  2. 缓存策略不当

    • 误区：缓存时间设置过长导致数据陈旧
    • 正确做法：根据数据类型设置合理的缓存时间，实时数据（如日内交易数据）缓存时间应较短（15-30分钟），历史数据可适当延长（1-24小时）

6.2 使用习惯误区

  1. 请求频率控制不足

    • 误区：仅在循环中添加固定延迟，未考虑API响应时间变化
    • 正确做法：实现基于请求历史和响应状态的自适应速率控制

  2. 错误处理不完善

    • 误区：仅捕获通用Exception而不区分具体错误类型
    • 正确做法：针对不同错误类型（429、403、超时等）实施差异化的重试和恢复策略

6.3 性能优化误区

  1. 过度并行化

    • 误区：使用多线程无限制并行请求以提高速度
    • 正确做法：根据API限制和网络条件合理设置并发数，通常建议不超过5-10个并发请求

  2. 忽视数据本地存储

    • 误区：每次运行都重新获取所有数据
    • 正确做法：实现本地数据库存储，仅更新变化的数据，减少API请求量

七、性能优化建议

7.1 代码级优化

  1. 批量请求优化

    # 使用Tickers类批量获取数据，减少网络往返
import yfinance as yf

tickers = yf.Tickers("AAPL MSFT GOOG AMZN TSLA")
# 一次性获取所有股票的历史数据
hist = tickers.history(period="1d")

  2. 数据字段筛选

    # 只获取需要的字段，减少数据传输量
ticker = yf.Ticker("AAPL")
# 仅获取收盘价和成交量
hist = ticker.history(period="1d", actions=False)
hist = hist[['Close', 'Volume']]

7.2 架构级优化

  1. 分层缓存策略

    • 内存缓存：频繁访问的少量数据
    • 磁盘缓存：中等访问频率的大量数据
    • 数据库存储：长期保留的历史数据

  2. 异步请求处理

    import asyncio
import aiohttp
import yfinance as yf

async def async_fetch(session, ticker):
    try:
        # 使用aiohttp自定义请求逻辑
        url = f"https://query1.finance.yahoo.com/v8/finance/chart/{ticker}"
        async with session.get(url) as response:
            return await response.json()
    except Exception as e:
        print(f"获取 {ticker} 失败: {str(e)}")
        return None

async def batch_async_fetch(tickers):
    async with aiohttp.ClientSession() as session:
        tasks = [async_fetch(session, ticker) for ticker in tickers]
        results = await asyncio.gather(*tasks)
        return dict(zip(tickers, results))

# 使用示例
tickers = ["AAPL", "MSFT", "GOOG", "AMZN", "TSLA"]
loop = asyncio.get_event_loop()
data = loop.run_until_complete(batch_async_fetch(tickers))

八、高级应用与未来趋势

8.1 分布式数据获取系统

版本控制与并行开发流程

大型应用中，可构建分布式数据获取系统：

  1. 任务分发层：负责将获取任务分配到不同节点
  2. 执行节点层：运行多个数据获取实例，每个实例有独立的代理池和速率控制
  3. 数据聚合层：收集、验证和整合各节点获取的数据
  4. 监控告警层：实时监控系统状态，异常时触发告警

8.2 智能预测与自适应控制

未来发展方向包括：

  1. 基于机器学习的请求模式优化：通过历史数据训练模型，预测最佳请求间隔
  2. 自动代理质量评估：实时测试代理性能，动态调整代理优先级
  3. 异常检测与自动恢复：识别异常请求模式，自动调整系统参数

8.3 替代数据源集成

为提高系统健壮性，可集成多种数据源：

  1. 主要数据源：Yahoo Finance API（通过yfinance）
  2. 备用数据源：Alpha Vantage、Polygon等
  3. 数据验证机制：交叉验证不同来源的数据，确保准确性

九、最佳实践总结

9.1 入门级实践

  1. 基础配置

    • 始终使用最新版本的yfinance
    • 配置合理的代理服务器
    • 实现基础的请求延迟控制

  2. 错误处理

    • 为所有API调用添加try-except块
    • 实现简单的重试机制
    • 记录关键错误信息

9.2 进阶级实践

  1. 系统优化

    • 实现多层缓存策略
    • 使用自适应速率控制
    • 构建代理池管理机制

  2. 监控与维护

    • 建立性能监控系统
    • 定期评估代理质量
    • 分析请求模式并优化

9.3 专家级实践

  1. 架构设计

    • 构建分布式数据获取系统
    • 实现多数据源冗余
    • 设计智能请求调度算法

  2. 持续优化

    • A/B测试不同策略
    • 基于数据分析优化参数
    • 预测并适应API变化

通过本文介绍的解决方案和最佳实践，开发者可以构建一个稳定、高效的yfinance数据获取系统，有效解决访问受限问题，为金融数据分析和决策提供可靠的数据支持。随着API生态的不断变化，持续监控和调整策略将是保持系统长期稳定运行的关键。

yfinance
Download market data from Yahoo! Finance's API
项目地址：https://gitcode.com/GitHub_Trending/yf/yfinance
登录后查看全文

相关内容推荐

1 彻底解决yfinance API访问受限问题：权限控制与速率限制全攻略2 攻克yfinance数据获取难题：从错误排查到稳定运行的实战指南3 4个实战维度掌握yfinance：从数据获取到投资决策支持4 5个实战技巧：用yfinance解决金融数据采集中的关键难题5 高效实战：yfinance金融数据获取全指南6 从数据到决策：3大维度解锁yfinance的金融数据处理能力7 5天精通yfinance：Python金融数据获取与分析完全指南8 3个核心步骤掌握yfinance，让股票数据分析效率提升50%9 解锁3大核心能力：yfinance金融数据获取与处理全指南10 股票数据获取与Python财经分析：yfinance工具全攻略
热门项目推荐
相关项目推荐

热门内容推荐

1 编程实践项目探索指南：从零构建技术能力体系2 技术解构式学习：从0到1构建你的编程知识体系3 构建自己的技术世界：build-your-own-x项目的实践探索指南4 解锁编程技能的实践之旅：从零构建你的技术世界5 技术实践探索：从零开始构建核心系统的实践指南6 亲手锻造技术引擎：从0到1构建核心系统的实践指南

最新内容推荐

AcFunDown视频下载工具完全指南还在为数字笔记抓狂？这款开源神器让手写批注效率提升300%Windows笔记本电池健康管理全指南：从根源解决电池损耗问题gmx_MMPBSA分子间相互作用索引错误的深度诊断与解决Axure RP 11 本地化方案：Mac中文界面优化与原型设计工具汉化全指南如何高效获取教育资源？这款工具让教材下载效率提升80%视频元数据深度编辑：专业技巧与案例网盘直链下载技术解析与应用指南如何用DeepSeek-R1推理模型提升复杂任务解决能力：完整指南5个突破瓶颈技巧：硬件优化工具让你的电脑性能提升30%

项目优选

收起
kernelkernel
deepin linux kernel
C
29
16
docsdocs
暂无描述
Dockerfile
727
4.66 K
pytorchpytorch
Ascend Extension for PyTorch
Python
599
751
atomcodeatomcode
Claude Code 的开源替代方案。连接任意大模型，编辑代码，运行命令，自动验证 — 全自动执行。用 Rust 构建，极致性能。 ｜ An open-source alternative to Claude Code. Connect any LLM, edit code, run commands, and verify changes — autonomously. Built in Rust for speed. Get Started
Rust
1.02 K
139
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.66 K
971
flutter_flutterflutter_flutter
暂无简介
Dart
970
246
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
427
377
openHiTLSopenHiTLS
旨在打造算法先进、性能卓越、高效敏捷、安全可靠的密码套件，通过轻量级、可剪裁的软件技术架构满足各行业不同场景的多样化要求，让密码技术应用更简单，同时探索后量子等先进算法创新实践，构建密码前沿技术底座！
C
1.09 K
610
ppt-masterppt-master
AI 将任意文档转换为精美可编辑的 PPTX 演示文稿 — 无需设计基础 | 包含 15 个案例、229 页内容
Python
122
7
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
992
988