Cursor编程-从入门到精通#

1
2
3
4
5
6
7
8

cursor_features = {
    "AI代码生成": "基于自然语言描述生成代码",
    "智能补全": "上下文相关的代码补全",
    "代码解释": "理解和解释复杂代码逻辑",  
    "错误诊断": "自动识别和修复代码错误",
    "重构优化": "代码结构优化和性能提升",
    "文档生成": "自动生成代码文档和注释"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// .cursorrules 文件示例
{
  "rules": {
    "language": "Python",
    "framework": "Django", 
    "style": "PEP 8",
    "testing": "pytest",
    "documentation": "Google Style"
  },
  
  "preferences": {
    "code_style": "简洁优雅",
    "error_handling": "详细的异常处理",
    "comments": "关键逻辑必须有注释",
    "naming": "描述性变量名"
  },
  
  "context": {
    "project_type": "Web应用",
    "team_size": "5人",
    "experience_level": "中级",
    "performance_priority": "高"
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# React项目的Cursor Rules
project_type: "React Web App"
preferences:
  - 使用函数组件和Hooks
  - TypeScript严格模式
  - ESLint + Prettier代码规范
  - 组件库：Material-UI
  - 状态管理：Redux Toolkit
  
coding_standards:
  - 单一职责原则
  - 组件名使用PascalCase
  - 文件名使用camelCase
  - 详细的PropTypes定义
  
best_practices:
  - 性能优化：使用React.memo
  - 错误边界：每个页面组件
  - 测试：Jest + React Testing Library
  - 无障碍：遵循WCAG 2.1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 输入描述：创建一个计算斐波那契数列的函数，支持缓存
# Cursor生成的代码：

from functools import lru_cache

@lru_cache(maxsize=128)
def fibonacci(n: int) -> int:
    """
    计算斐波那契数列的第n项（支持缓存优化）
    
    Args:
        n: 非负整数，表示数列的位置
        
    Returns:
        第n项的斐波那契数
        
    Raises:
        ValueError: 当n为负数时抛出异常
    """
    if n < 0:
        raise ValueError("n must be non-negative")
    
    if n <= 1:
        return n
    
    return fibonacci(n - 1) + fibonacci(n - 2)

# 使用示例
if __name__ == "__main__":
    # 计算前10项
    for i in range(10):
        print(f"F({i}) = {fibonacci(i)}")
    
    # 性能测试
    import time
    start = time.time()
    result = fibonacci(100)
    end = time.time()
    print(f"F(100) = {result}, 计算用时: {end - start:.4f}秒")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

# 输入：实现一个线程安全的单例模式
# Cursor生成：

import threading
from typing import Optional, Any

class ThreadSafeSingleton:
    """
    线程安全的单例模式实现
    使用双重检查锁定模式确保线程安全
    """
    
    _instance: Optional['ThreadSafeSingleton'] = None
    _lock = threading.Lock()
    
    def __new__(cls, *args, **kwargs) -> 'ThreadSafeSingleton':
        # 第一次检查（无锁）
        if cls._instance is None:
            # 获取锁
            with cls._lock:
                # 第二次检查（有锁）
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance
    
    def __init__(self, data: Any = None):
        # 确保只初始化一次
        if not hasattr(self, '_initialized'):
            self.data = data
            self._initialized = True
    
    def get_data(self) -> Any:
        """获取单例数据"""
        return getattr(self, 'data', None)
    
    def set_data(self, data: Any) -> None:
        """设置单例数据"""
        self.data = data

# 测试代码
def test_singleton():
    """测试单例模式的正确性"""
    import concurrent.futures
    
    def create_instance(value):
        return ThreadSafeSingleton(value)
    
    # 并发创建实例
    with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
        futures = [executor.submit(create_instance, i) for i in range(10)]
        instances = [future.result() for future in futures]
    
    # 验证所有实例都是同一个对象
    assert all(instance is instances[0] for instance in instances)
    print("✓ 线程安全单例测试通过")

if __name__ == "__main__":
    test_singleton()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class DataProcessor:
    def __init__(self, data_source: str):
        self.data_source = data_source
        self.processed_data = []
    
    def load_data(self):
        # 当你输入 "def process_" 时，Cursor会智能建议：
        pass
    
    def process_data(self, transformation_func):
        """
        Cursor会根据类的上下文建议合适的实现：
        - 检查数据是否已加载
        - 应用转换函数  
        - 存储处理结果
        - 返回处理状态
        """
        if not self.processed_data:
            self.load_data()
        
        try:
            self.processed_data = [
                transformation_func(item) for item in self.raw_data
            ]
            return {"status": "success", "count": len(self.processed_data)}
        except Exception as e:
            return {"status": "error", "message": str(e)}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 复杂代码示例
def complex_algorithm(data, threshold=0.5, iterations=100):
    """Cursor可以解释这个复杂算法的工作原理"""
    
    weights = [0.1] * len(data)
    for epoch in range(iterations):
        errors = []
        for i, item in enumerate(data):
            prediction = sum(w * f for w, f in zip(weights, item['features']))
            error = item['target'] - prediction
            errors.append(abs(error))
            
            if abs(error) > threshold:
                learning_rate = 0.01 * (1 - epoch / iterations)
                for j, feature in enumerate(item['features']):
                    weights[j] += learning_rate * error * feature
        
        avg_error = sum(errors) / len(errors)
        if avg_error < threshold * 0.1:
            break
    
    return weights

# Cursor的解释：
"""
这是一个简化的感知器学习算法实现：

1. 初始化权重：所有权重初始化为0.1
2. 迭代训练过程：
   - 对每个数据点计算预测值（特征加权和）
   - 计算预测误差（目标值 - 预测值）
   - 如果误差大于阈值，更新权重
   - 使用递减的学习率（随epoch减少）
3. 早停机制：当平均误差足够小时提前终止
4. 返回训练好的权重

关键特点：
- 自适应学习率：随训练进度降低
- 在线学习：逐个样本更新权重
- 早停：避免过拟合
"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

# 原始代码（可改进）
def calculate_stats(numbers):
    total = 0
    count = 0
    for num in numbers:
        total += num
        count += 1
    average = total / count
    
    variance_sum = 0
    for num in numbers:
        variance_sum += (num - average) ** 2
    variance = variance_sum / count
    
    return total, count, average, variance

# Cursor重构后的代码
from typing import List, Tuple, NamedTuple
import statistics

class Statistics(NamedTuple):
    """统计结果数据类"""
    total: float
    count: int
    mean: float
    variance: float
    std_deviation: float

def calculate_statistics(numbers: List[float]) -> Statistics:
    """
    计算数值列表的统计信息
    
    Args:
        numbers: 数值列表
        
    Returns:
        Statistics: 包含各项统计指标的命名元组
        
    Raises:
        ValueError: 当输入列表为空时
    """
    if not numbers:
        raise ValueError("输入列表不能为空")
    
    total = sum(numbers)
    count = len(numbers)
    mean = statistics.mean(numbers)
    variance = statistics.variance(numbers)
    std_dev = statistics.stdev(numbers)
    
    return Statistics(
        total=total,
        count=count, 
        mean=mean,
        variance=variance,
        std_deviation=std_dev
    )

# 使用示例
if __name__ == "__main__":
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    stats = calculate_statistics(data)
    
    print(f"总和: {stats.total}")
    print(f"数量: {stats.count}")
    print(f"平均值: {stats.mean:.2f}")
    print(f"方差: {stats.variance:.2f}")
    print(f"标准差: {stats.std_deviation:.2f}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# Cursor可以分析整个项目结构并提供建议

project_analysis = {
    "architecture_review": {
        "strengths": [
            "清晰的模块分离",
            "遵循MVC模式",
            "良好的依赖注入"
        ],
        "improvements": [
            "添加单元测试覆盖",
            "实现API文档",
            "增加错误监控"
        ]
    },
    
    "code_quality": {
        "score": 8.5,
        "issues": [
            "部分函数过长，建议拆分",
            "缺少类型注解",
            "异常处理不够完善"
        ]
    },
    
    "security_review": {
        "vulnerabilities": [
            "SQL注入风险（users.py:45）",
            "未验证用户输入（api.py:67）"
        ],
        "recommendations": [
            "使用参数化查询",
            "添加输入验证中间件"
        ]
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

# 有bug的代码
def process_user_data(users):
    results = []
    for user in users:
        if user.age > 18:
            processed = {
                'name': user.name.upper(),
                'email': user.email.lower(),
                'score': user.score * 1.1
            }
            results.append(processed)
    return results

# Cursor诊断的潜在问题：
"""
🔍 潜在问题分析：

1. 空值处理缺失：
   - user.name 可能为None -> AttributeError
   - user.email 可能为None -> AttributeError
   
2. 数据类型假设：
   - user.age 可能不是数字
   - user.score 可能为None
   
3. 边界情况：
   - users列表可能为空
   - user对象可能缺少某些属性

🛠️ 修复建议：
"""

def process_user_data_safe(users):
    """安全的用户数据处理函数"""
    if not users:
        return []
    
    results = []
    for user in users:
        try:
            # 验证必要属性
            if not hasattr(user, 'age') or not isinstance(user.age, (int, float)):
                continue
                
            if user.age <= 18:
                continue
            
            # 安全的字符串处理
            name = getattr(user, 'name', '')
            email = getattr(user, 'email', '')
            score = getattr(user, 'score', 0)
            
            if not name or not email:
                continue
            
            processed = {
                'name': str(name).upper(),
                'email': str(email).lower(),
                'score': float(score) * 1.1 if score else 0
            }
            results.append(processed)
            
        except (AttributeError, ValueError, TypeError) as e:
            # 记录错误但继续处理其他用户
            print(f"处理用户数据时出错: {e}")
            continue
    
    return results

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

class APIEndpoint:
    """用户管理API端点"""
    
    def __init__(self, database_connection):
        self.db = database_connection
    
    # Cursor可以自动生成详细的API文档
    def create_user(self, user_data):
        """
        创建新用户
        
        Args:
            user_data (dict): 用户信息
                - name (str): 用户姓名，必填，2-50字符
                - email (str): 邮箱地址，必填，需符合邮箱格式
                - age (int): 年龄，必填，18-120之间
                - phone (str, optional): 手机号码，可选
                
        Returns:
            dict: 创建结果
                - success (bool): 是否成功
                - user_id (int): 新用户ID（成功时）
                - message (str): 结果消息
                
        Raises:
            ValueError: 当输入数据不合法时
            DatabaseError: 当数据库操作失败时
            
        Example:
            >>> api = APIEndpoint(db_connection)
            >>> result = api.create_user({
            ...     'name': '张三',
            ...     'email': 'zhangsan@example.com', 
            ...     'age': 25
            ... })
            >>> print(result)
            {'success': True, 'user_id': 123, 'message': '用户创建成功'}
        """
        pass

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

# 需求：处理多个Excel文件，合并数据并生成报告
# Cursor辅助生成的完整解决方案：

import pandas as pd
import os
from pathlib import Path
from typing import List, Dict, Any
import logging

class ExcelReportProcessor:
    """Excel报表批量处理器"""
    
    def __init__(self, input_dir: str, output_dir: str):
        self.input_dir = Path(input_dir)
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
        
        # 配置日志
        logging.basicConfig(level=logging.INFO)
        self.logger = logging.getLogger(__name__)
    
    def find_excel_files(self) -> List[Path]:
        """查找所有Excel文件"""
        excel_files = []
        for ext in ['*.xlsx', '*.xls']:
            excel_files.extend(self.input_dir.glob(ext))
        
        self.logger.info(f"找到 {len(excel_files)} 个Excel文件")
        return excel_files
    
    def read_excel_file(self, file_path: Path) -> Dict[str, pd.DataFrame]:
        """读取Excel文件的所有工作表"""
        try:
            sheets = pd.read_excel(file_path, sheet_name=None)
            self.logger.info(f"成功读取文件: {file_path.name}")
            return sheets
        except Exception as e:
            self.logger.error(f"读取文件失败 {file_path.name}: {e}")
            return {}
    
    def merge_dataframes(self, all_data: List[pd.DataFrame]) -> pd.DataFrame:
        """合并多个DataFrame"""
        if not all_data:
            return pd.DataFrame()
        
        # 统一列名（处理大小写和空格问题）
        for df in all_data:
            df.columns = df.columns.str.strip().str.lower()
        
        # 合并数据
        merged_df = pd.concat(all_data, ignore_index=True)
        
        # 数据清洗
        merged_df = merged_df.dropna(how='all')  # 删除全空行
        merged_df = merged_df.drop_duplicates()  # 删除重复行
        
        return merged_df
    
    def generate_summary_report(self, df: pd.DataFrame) -> Dict[str, Any]:
        """生成汇总报告"""
        report = {
            "basic_stats": {
                "total_rows": len(df),
                "total_columns": len(df.columns),
                "memory_usage": df.memory_usage(deep=True).sum(),
                "null_values": df.isnull().sum().sum()
            },
            "data_types": df.dtypes.value_counts().to_dict(),
            "numeric_summary": {}
        }
        
        # 数值列统计
        numeric_cols = df.select_dtypes(include=['number']).columns
        for col in numeric_cols:
            report["numeric_summary"][col] = {
                "mean": df[col].mean(),
                "median": df[col].median(),
                "std": df[col].std(),
                "min": df[col].min(),
                "max": df[col].max()
            }
        
        return report
    
    def process_all_files(self) -> None:
        """处理所有Excel文件"""
        excel_files = self.find_excel_files()
        all_dataframes = []
        
        for file_path in excel_files:
            sheets = self.read_excel_file(file_path)
            
            for sheet_name, df in sheets.items():
                if not df.empty:
                    # 添加数据源信息
                    df['source_file'] = file_path.name
                    df['source_sheet'] = sheet_name
                    all_dataframes.append(df)
        
        # 合并所有数据
        merged_data = self.merge_dataframes(all_dataframes)
        
        if merged_data.empty:
            self.logger.warning("没有找到有效数据")
            return
        
        # 生成报告
        summary_report = self.generate_summary_report(merged_data)
        
        # 保存结果
        self.save_results(merged_data, summary_report)
    
    def save_results(self, merged_data: pd.DataFrame, report: Dict[str, Any]) -> None:
        """保存处理结果"""
        # 保存合并后的数据
        output_file = self.output_dir / "merged_data.xlsx"
        with pd.ExcelWriter(output_file, engine='openpyxl') as writer:
            merged_data.to_excel(writer, sheet_name='合并数据', index=False)
            
            # 创建汇总报告工作表
            report_df = pd.DataFrame([
                ["总行数", report["basic_stats"]["total_rows"]],
                ["总列数", report["basic_stats"]["total_columns"]],
                ["内存使用", f"{report['basic_stats']['memory_usage']/1024/1024:.2f} MB"],
                ["空值数量", report["basic_stats"]["null_values"]]
            ], columns=["指标", "值"])
            
            report_df.to_excel(writer, sheet_name='汇总报告', index=False)
        
        self.logger.info(f"结果已保存到: {output_file}")

# 使用示例
if __name__ == "__main__":
    processor = ExcelReportProcessor(
        input_dir="./excel_files",
        output_dir="./processed_reports"
    )
    processor.process_all_files()

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256

# Cursor辅助创建疫情监控大屏
import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from datetime import datetime, timedelta
import requests

class COVID19Dashboard:
    """疫情实时监控大屏"""
    
    def __init__(self):
        st.set_page_config(
            page_title="疫情实时监控大屏",
            page_icon="🦠",
            layout="wide",
            initial_sidebar_state="collapsed"
        )
        
        # 自定义CSS样式
        self.load_custom_css()
    
    def load_custom_css(self):
        """加载自定义CSS样式"""
        st.markdown("""
        <style>
        .main-header {
            font-size: 2.5rem;
            color: #1f77b4;
            text-align: center;
            padding: 1rem 0;
            border-bottom: 2px solid #1f77b4;
            margin-bottom: 2rem;
        }
        
        .metric-card {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            padding: 1rem;
            border-radius: 10px;
            color: white;
            text-align: center;
            margin: 0.5rem 0;
        }
        
        .alert-box {
            background: #ff6b6b;
            color: white;
            padding: 1rem;
            border-radius: 5px;
            margin: 1rem 0;
        }
        </style>
        """, unsafe_allow_html=True)
    
    def fetch_covid_data(self):
        """获取疫情数据（模拟）"""
        # 实际应用中应该调用真实的疫情数据API
        import random
        
        regions = ['北京', '上海', '广州', '深圳', '杭州', '南京', '武汉', '成都']
        data = []
        
        for region in regions:
            data.append({
                'region': region,
                'confirmed': random.randint(100, 10000),
                'cured': random.randint(50, 8000),
                'deaths': random.randint(0, 100),
                'risk_level': random.choice(['低风险', '中风险', '高风险']),
                'last_update': datetime.now().strftime('%Y-%m-%d %H:%M')
            })
        
        return pd.DataFrame(data)
    
    def create_overview_metrics(self, df):
        """创建概览指标卡片"""
        total_confirmed = df['confirmed'].sum()
        total_cured = df['cured'].sum()
        total_deaths = df['deaths'].sum()
        cure_rate = (total_cured / total_confirmed * 100) if total_confirmed > 0 else 0
        
        col1, col2, col3, col4 = st.columns(4)
        
        with col1:
            st.metric(
                label="累计确诊",
                value=f"{total_confirmed:,}",
                delta=f"+{random.randint(0, 100)}",
                delta_color="inverse"
            )
        
        with col2:
            st.metric(
                label="累计治愈", 
                value=f"{total_cured:,}",
                delta=f"+{random.randint(0, 50)}",
                delta_color="normal"
            )
        
        with col3:
            st.metric(
                label="累计死亡",
                value=f"{total_deaths:,}",
                delta=f"+{random.randint(0, 5)}",
                delta_color="inverse"
            )
        
        with col4:
            st.metric(
                label="治愈率",
                value=f"{cure_rate:.1f}%",
                delta=f"+0.{random.randint(1, 9)}%",
                delta_color="normal"
            )
    
    def create_regional_chart(self, df):
        """创建地区分布图表"""
        col1, col2 = st.columns(2)
        
        with col1:
            st.subheader("地区确诊分布")
            fig_bar = px.bar(
                df, 
                x='region', 
                y='confirmed',
                color='risk_level',
                color_discrete_map={
                    '低风险': '#2ecc71',
                    '中风险': '#f39c12', 
                    '高风险': '#e74c3c'
                },
                title="各地区确诊病例数"
            )
            fig_bar.update_layout(showlegend=True)
            st.plotly_chart(fig_bar, use_container_width=True)
        
        with col2:
            st.subheader("治愈率对比")
            df['cure_rate'] = (df['cured'] / df['confirmed'] * 100).round(1)
            
            fig_scatter = px.scatter(
                df,
                x='confirmed',
                y='cure_rate', 
                size='cured',
                color='risk_level',
                hover_data=['region'],
                title="确诊数量 vs 治愈率"
            )
            st.plotly_chart(fig_scatter, use_container_width=True)
    
    def create_trend_chart(self):
        """创建趋势图表"""
        st.subheader("疫情趋势分析")
        
        # 生成模拟的时间序列数据
        dates = pd.date_range(
            start=datetime.now() - timedelta(days=30),
            end=datetime.now(),
            freq='D'
        )
        
        trend_data = pd.DataFrame({
            'date': dates,
            'confirmed': [random.randint(100, 500) for _ in range(len(dates))],
            'cured': [random.randint(80, 400) for _ in range(len(dates))],
            'deaths': [random.randint(0, 20) for _ in range(len(dates))]
        })
        
        # 计算累计值
        trend_data['cumulative_confirmed'] = trend_data['confirmed'].cumsum()
        trend_data['cumulative_cured'] = trend_data['cured'].cumsum()
        trend_data['cumulative_deaths'] = trend_data['deaths'].cumsum()
        
        fig_trend = go.Figure()
        
        fig_trend.add_trace(go.Scatter(
            x=trend_data['date'],
            y=trend_data['cumulative_confirmed'],
            mode='lines+markers',
            name='累计确诊',
            line=dict(color='#e74c3c', width=3)
        ))
        
        fig_trend.add_trace(go.Scatter(
            x=trend_data['date'],
            y=trend_data['cumulative_cured'],
            mode='lines+markers', 
            name='累计治愈',
            line=dict(color='#2ecc71', width=3)
        ))
        
        fig_trend.update_layout(
            title="疫情发展趋势",
            xaxis_title="日期",
            yaxis_title="累计人数",
            hovermode='x unified'
        )
        
        st.plotly_chart(fig_trend, use_container_width=True)
    
    def create_risk_alerts(self, df):
        """创建风险预警"""
        st.subheader("🚨 风险预警")
        
        high_risk_regions = df[df['risk_level'] == '高风险']['region'].tolist()
        
        if high_risk_regions:
            st.error(f"高风险地区：{', '.join(high_risk_regions)}")
        
        # 新增病例预警
        recent_increase = df[df['confirmed'] > 1000]['region'].tolist()
        if recent_increase:
            st.warning(f"病例数较高地区：{', '.join(recent_increase)}")
        
        # 治愈率偏低预警
        df['cure_rate'] = df['cured'] / df['confirmed'] * 100
        low_cure_rate = df[df['cure_rate'] < 80]['region'].tolist()
        if low_cure_rate:
            st.info(f"治愈率有待提升地区：{', '.join(low_cure_rate)}")
    
    def run_dashboard(self):
        """运行仪表盘"""
        st.markdown('<h1 class="main-header">🦠 疫情实时监控大屏</h1>', 
                   unsafe_allow_html=True)
        
        # 获取数据
        df = self.fetch_covid_data()
        
        # 显示最后更新时间
        st.sidebar.info(f"最后更新：{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
        
        # 自动刷新按钮
        if st.sidebar.button("🔄 刷新数据"):
            st.experimental_rerun()
        
        # 概览指标
        self.create_overview_metrics(df)
        
        # 地区分布图表
        self.create_regional_chart(df)
        
        # 趋势分析
        self.create_trend_chart()
        
        # 风险预警
        self.create_risk_alerts(df)
        
        # 详细数据表
        with st.expander("📊 详细数据"):
            st.dataframe(df, use_container_width=True)

# 运行应用
if __name__ == "__main__":
    dashboard = COVID19Dashboard()
    dashboard.run_dashboard()