# requirements.txt
# 自動(dòng)化腳本常用庫
requests>=2.28.0          # 網(wǎng)絡(luò)請(qǐng)求
pandas>=1.5.0             # 數(shù)據(jù)處理
openpyxl>=3.0.0           # Excel操作
selenium>=4.0.0           # 網(wǎng)頁自動(dòng)化
beautifulsoup4>=4.11.0    # HTML解析
python-docx>=0.8.0        # Word文檔操作
pyautogui>=0.9.0          # 圖形界面自動(dòng)化
schedule>=1.1.0           # 任務(wù)調(diào)度
pillow>=9.0.0             # 圖像處理
pywin32>=300.0.0          # Windows系統(tǒng)操作

pip install -r requirements.txt

import os
import shutil
import logging
from pathlib import Path
from datetime import datetime

class FileOrganizer:
    """
    智能文件整理器
    自動(dòng)根據(jù)文件類型分類并整理文件
    """
    
    # 文件類型與文件夾的映射
    FILE_CATEGORIES = {
        'Images': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg', '.webp'],
        'Documents': ['.pdf', '.doc', '.docx', '.txt', '.rtf', '.xlsx', '.pptx'],
        'Audio': ['.mp3', '.wav', '.flac', '.aac', '.ogg'],
        'Video': ['.mp4', '.avi', '.mov', '.wmv', '.flv', '.mkv'],
        'Archives': ['.zip', '.rar', '.7z', '.tar', '.gz'],
        'Code': ['.py', '.js', '.html', '.css', '.java', '.cpp', '.c'],
        'Executables': ['.exe', '.msi', '.dmg', '.pkg']
    }
    
    def __init__(self, target_directory):
        """
        初始化文件整理器
        
        Args:
            target_directory (str): 要整理的目錄路徑
        """
        self.target_dir = Path(target_directory)
        self.setup_logging()
        
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('file_organizer.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def get_file_category(self, file_extension):
        """
        根據(jù)文件擴(kuò)展名獲取文件類別
        
        Args:
            file_extension (str): 文件擴(kuò)展名
            
        Returns:
            str: 文件類別名稱
        """
        for category, extensions in self.FILE_CATEGORIES.items():
            if file_extension.lower() in extensions:
                return category
        return 'Others'
    
    def create_category_folders(self):
        """創(chuàng)建分類文件夾"""
        for category in list(self.FILE_CATEGORIES.keys()) + ['Others']:
            category_path = self.target_dir / category
            category_path.mkdir(exist_ok=True)
    
    def organize_files(self, dry_run=False):
        """
        整理文件
        
        Args:
            dry_run (bool): 是否為試運(yùn)行模式（不實(shí)際移動(dòng)文件）
            
        Returns:
            dict: 整理統(tǒng)計(jì)信息
        """
        self.logger.info(f"開始整理目錄: {self.target_dir}")
        
        if not self.target_dir.exists():
            self.logger.error(f"目錄不存在: {self.target_dir}")
            return {}
        
        # 創(chuàng)建分類文件夾
        self.create_category_folders()
        
        # 統(tǒng)計(jì)信息
        stats = {
            'total_files': 0,
            'moved_files': 0,
            'skipped_files': 0,
            'errors': 0,
            'file_categories': {}
        }
        
        try:
            for file_path in self.target_dir.iterdir():
                # 跳過目錄和隱藏文件
                if file_path.is_dir() or file_path.name.startswith('.'):
                    continue
                    
                stats['total_files'] += 1
                file_extension = file_path.suffix
                category = self.get_file_category(file_extension)
                
                # 更新類別統(tǒng)計(jì)
                if category not in stats['file_categories']:
                    stats['file_categories'][category] = 0
                stats['file_categories'][category] += 1
                
                # 目標(biāo)路徑
                target_path = self.target_dir / category / file_path.name
                
                # 處理文件名沖突
                counter = 1
                while target_path.exists():
                    stem = file_path.stem
                    new_name = f"{stem}_{counter}{file_extension}"
                    target_path = self.target_dir / category / new_name
                    counter += 1
                
                if dry_run:
                    self.logger.info(f"[試運(yùn)行] 將移動(dòng): {file_path.name} -> {category}/")
                    stats['moved_files'] += 1
                else:
                    try:
                        shutil.move(str(file_path), str(target_path))
                        self.logger.info(f"已移動(dòng): {file_path.name} -> {category}/")
                        stats['moved_files'] += 1
                    except Exception as e:
                        self.logger.error(f"移動(dòng)文件失敗 {file_path.name}: {str(e)}")
                        stats['errors'] += 1
                        
        except Exception as e:
            self.logger.error(f"整理過程發(fā)生錯(cuò)誤: {str(e)}")
            stats['errors'] += 1
        
        # 記錄統(tǒng)計(jì)信息
        self.logger.info(f"整理完成: 總共{stats['total_files']}個(gè)文件, "
                        f"移動(dòng){stats['moved_files']}個(gè), "
                        f"錯(cuò)誤{stats['errors']}個(gè)")
        
        return stats
    
    def find_duplicate_files(self):
        """
        查找重復(fù)文件
        
        Returns:
            list: 重復(fù)文件組列表
        """
        self.logger.info("開始查找重復(fù)文件...")
        
        file_hashes = {}
        duplicates = []
        
        for file_path in self.target_dir.rglob('*'):
            if file_path.is_file():
                try:
                    # 使用文件大小和修改時(shí)間作為初步判斷
                    file_stat = file_path.stat()
                    file_key = (file_stat.st_size, file_stat.st_mtime)
                    
                    if file_key in file_hashes:
                        # 計(jì)算MD5進(jìn)行精確比較
                        import hashlib
                        with open(file_path, 'rb') as f:
                            file_hash = hashlib.md5(f.read()).hexdigest()
                        
                        if file_hash in [h for _, h in file_hashes[file_key]]:
                            duplicates.append(str(file_path))
                    else:
                        file_hashes[file_key] = [(str(file_path), file_hash)]
                        
                except Exception as e:
                    self.logger.warning(f"處理文件失敗 {file_path}: {str(e)}")
        
        self.logger.info(f"找到 {len(duplicates)} 個(gè)重復(fù)文件")
        return duplicates

# 使用示例
def demo_file_organizer():
    """演示文件整理器的使用"""
    # 初始化整理器（假設(shè)整理下載文件夾）
    organizer = FileOrganizer(r"C:\Users\YourName\Downloads")
    
    # 先進(jìn)行試運(yùn)行
    print("=== 試運(yùn)行模式 ===")
    stats = organizer.organize_files(dry_run=True)
    
    # 確認(rèn)后實(shí)際執(zhí)行
    user_input = input("\n確認(rèn)執(zhí)行整理？(y/n): ")
    if user_input.lower() == 'y':
        print("=== 實(shí)際執(zhí)行 ===")
        stats = organizer.organize_files(dry_run=False)
        
        # 顯示統(tǒng)計(jì)信息
        print(f"\n=== 整理統(tǒng)計(jì) ===")
        print(f"總文件數(shù): {stats['total_files']}")
        print(f"移動(dòng)文件: {stats['moved_files']}")
        print(f"錯(cuò)誤數(shù)量: {stats['errors']}")
        print("文件分類統(tǒng)計(jì):")
        for category, count in stats['file_categories'].items():
            print(f"  {category}: {count}個(gè)文件")
    
    # 查找重復(fù)文件
    print("\n=== 查找重復(fù)文件 ===")
    duplicates = organizer.find_duplicate_files()
    if duplicates:
        print("發(fā)現(xiàn)重復(fù)文件:")
        for dup in duplicates[:5]:  # 只顯示前5個(gè)
            print(f"  {dup}")
    else:
        print("未發(fā)現(xiàn)重復(fù)文件")

if __name__ == "__main__":
    demo_file_organizer()

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import os
import logging
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment
from openpyxl.chart import BarChart, Reference
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders

class ExcelReportGenerator:
    """
    Excel報(bào)表自動(dòng)生成器
    自動(dòng)從數(shù)據(jù)源生成格式化的Excel報(bào)表
    """
    
    def __init__(self, output_path="reports"):
        """
        初始化報(bào)表生成器
        
        Args:
            output_path (str): 報(bào)表輸出目錄
        """
        self.output_path = Path(output_path)
        self.output_path.mkdir(exist_ok=True)
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def generate_sample_data(self):
        """
        生成示例銷售數(shù)據(jù)
        
        Returns:
            pd.DataFrame: 銷售數(shù)據(jù)
        """
        np.random.seed(42)
        dates = pd.date_range(start='2024-01-01', end='2024-01-31', freq='D')
        
        data = {
            'date': dates,
            'product': np.random.choice(['Product A', 'Product B', 'Product C'], len(dates)),
            'category': np.random.choice(['Electronics', 'Clothing', 'Books'], len(dates)),
            'sales': np.random.randint(100, 5000, len(dates)),
            'quantity': np.random.randint(1, 100, len(dates)),
            'region': np.random.choice(['North', 'South', 'East', 'West'], len(dates))
        }
        
        df = pd.DataFrame(data)
        df['revenue'] = df['sales'] * df['quantity']
        return df
    
    def create_formatted_excel(self, df, filename):
        """
        創(chuàng)建格式化的Excel報(bào)表
        
        Args:
            df (pd.DataFrame): 數(shù)據(jù)框
            filename (str): 輸出文件名
            
        Returns:
            str: 生成的文件路徑
        """
        try:
            # 創(chuàng)建Excel工作簿
            wb = Workbook()
            ws = wb.active
            ws.title = "銷售報(bào)表"
            
            # 設(shè)置標(biāo)題
            title = "月度銷售報(bào)告 - {}".format(datetime.now().strftime("%Y年%m月"))
            ws['A1'] = title
            ws.merge_cells('A1:F1')
            title_cell = ws['A1']
            title_cell.font = Font(size=16, bold=True)
            title_cell.alignment = Alignment(horizontal='center')
            
            # 添加數(shù)據(jù)
            headers = list(df.columns)
            for col, header in enumerate(headers, 1):
                cell = ws.cell(row=3, column=col, value=header)
                cell.font = Font(bold=True)
                cell.fill = PatternFill(start_color="DDDDDD", end_color="DDDDDD", fill_type="solid")
            
            for row, (_, data_row) in enumerate(df.iterrows(), 4):
                for col, value in enumerate(data_row, 1):
                    ws.cell(row=row, column=col, value=value)
            
            # 添加匯總行
            summary_row = len(df) + 5
            ws.cell(row=summary_row, column=4, value="總計(jì):").font = Font(bold=True)
            ws.cell(row=summary_row, column=5, value=f"=SUM(E4:E{len(df)+3})")
            ws.cell(row=summary_row, column=6, value=f"=SUM(F4:F{len(df)+3})")
            
            # 創(chuàng)建圖表
            self.add_charts(ws, df, len(df) + 8)
            
            # 自動(dòng)調(diào)整列寬
            for column in ws.columns:
                max_length = 0
                column_letter = column[0].column_letter
                for cell in column:
                    try:
                        if len(str(cell.value)) > max_length:
                            max_length = len(str(cell.value))
                    except:
                        pass
                adjusted_width = (max_length + 2)
                ws.column_dimensions[column_letter].width = adjusted_width
            
            # 保存文件
            filepath = self.output_path / filename
            wb.save(filepath)
            self.logger.info(f"Excel報(bào)表已生成: {filepath}")
            
            return str(filepath)
            
        except Exception as e:
            self.logger.error(f"生成Excel報(bào)表失敗: {str(e)}")
            return None
    
    def add_charts(self, worksheet, df, start_row):
        """
        添加圖表到工作表
        
        Args:
            worksheet: Excel工作表
            df (pd.DataFrame): 數(shù)據(jù)
            start_row (int): 圖表起始行
        """
        try:
            # 按產(chǎn)品匯總銷售數(shù)據(jù)
            product_sales = df.groupby('product')['sales'].sum().reset_index()
            
            # 創(chuàng)建柱狀圖
            chart = BarChart()
            chart.title = "產(chǎn)品銷售對(duì)比"
            chart.x_axis.title = "產(chǎn)品"
            chart.y_axis.title = "銷售額"
            
            # 準(zhǔn)備圖表數(shù)據(jù)
            data = Reference(worksheet, 
                           min_col=5, min_row=3, 
                           max_col=5, max_row=3 + len(product_sales))
            categories = Reference(worksheet,
                                 min_col=2, min_row=4,
                                 max_row=3 + len(product_sales))
            
            chart.add_data(data, titles_from_data=True)
            chart.set_categories(categories)
            
            # 將圖表添加到工作表
            worksheet.add_chart(chart, f"A{start_row}")
            
        except Exception as e:
            self.logger.warning(f"添加圖表失敗: {str(e)}")
    
    def send_report_email(self, filepath, recipient_email):
        """
        發(fā)送報(bào)表郵件（需要配置SMTP）
        
        Args:
            filepath (str): 報(bào)表文件路徑
            recipient_email (str): 收件人郵箱
        """
        try:
            # 郵件配置（需要根據(jù)實(shí)際情況修改）
            smtp_server = "smtp.example.com"
            smtp_port = 587
            sender_email = "reports@company.com"
            sender_password = "password"
            
            # 創(chuàng)建郵件
            msg = MIMEMultipart()
            msg['From'] = sender_email
            msg['To'] = recipient_email
            msg['Subject'] = "月度銷售報(bào)告"
            
            # 郵件正文
            body = f"您好，\n\n附件是{datetime.now().strftime('%Y年%m月')}的銷售報(bào)告。\n\n此郵件為自動(dòng)發(fā)送，請(qǐng)勿回復(fù)。"
            msg.attach(MIMEText(body, 'plain'))
            
            # 添加附件
            with open(filepath, "rb") as attachment:
                part = MIMEBase('application', 'octet-stream')
                part.set_payload(attachment.read())
            
            encoders.encode_base64(part)
            part.add_header(
                'Content-Disposition',
                f'attachment; filename= {os.path.basename(filepath)}'
            )
            msg.attach(part)
            
            # 發(fā)送郵件
            server = smtplib.SMTP(smtp_server, smtp_port)
            server.starttls()
            server.login(sender_email, sender_password)
            server.send_message(msg)
            server.quit()
            
            self.logger.info(f"報(bào)表郵件已發(fā)送至: {recipient_email}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送郵件失敗: {str(e)}")

# 使用示例
def demo_excel_reporter():
    """演示Excel報(bào)表生成器的使用"""
    generator = ExcelReportGenerator()
    
    # 生成示例數(shù)據(jù)
    df = generator.generate_sample_data()
    
    # 生成Excel報(bào)表
    filename = f"sales_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
    filepath = generator.create_formatted_excel(df, filename)
    
    if filepath:
        print(f"報(bào)表已生成: {filepath}")
        
        # 顯示數(shù)據(jù)統(tǒng)計(jì)
        print("\n=== 數(shù)據(jù)統(tǒng)計(jì) ===")
        print(f"總記錄數(shù): {len(df)}")
        print(f"總銷售額: {df['sales'].sum():,}")
        print(f"總收入: {df['revenue'].sum():,}")
        print("\n按產(chǎn)品統(tǒng)計(jì):")
        product_stats = df.groupby('product').agg({
            'sales': ['sum', 'mean', 'count'],
            'revenue': 'sum'
        }).round(2)
        print(product_stats)
    
    return filepath

if __name__ == "__main__":
    demo_excel_reporter()

import requests
from bs4 import BeautifulSoup
import hashlib
import time
import json
import logging
from datetime import datetime
from pathlib import Path
import smtplib
from email.mime.text import MIMEText
import schedule

class WebContentMonitor:
    """
    網(wǎng)頁內(nèi)容監(jiān)控器
    監(jiān)控網(wǎng)頁內(nèi)容變化并發(fā)送通知
    """
    
    def __init__(self, config_file="monitor_config.json"):
        """
        初始化監(jiān)控器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.monitor_data = self.load_monitor_data()
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('web_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_monitor_data(self):
        """
        加載監(jiān)控?cái)?shù)據(jù)
        
        Returns:
            dict: 監(jiān)控?cái)?shù)據(jù)
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "websites": {},
                "check_interval": 300,  # 5分鐘
                "email_config": {
                    "smtp_server": "smtp.example.com",
                    "smtp_port": 587,
                    "sender_email": "monitor@example.com",
                    "sender_password": "password",
                    "recipient_email": "user@example.com"
                }
            }
            self.save_monitor_data(default_config)
            return default_config
    
    def save_monitor_data(self, data=None):
        """
        保存監(jiān)控?cái)?shù)據(jù)
        
        Args:
            data (dict): 要保存的數(shù)據(jù)
        """
        if data is None:
            data = self.monitor_data
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
    
    def add_website(self, name, url, css_selector=None):
        """
        添加要監(jiān)控的網(wǎng)站
        
        Args:
            name (str): 網(wǎng)站名稱
            url (str): 網(wǎng)站URL
            css_selector (str): 要監(jiān)控的CSS選擇器（可選）
        """
        if name not in self.monitor_data["websites"]:
            self.monitor_data["websites"][name] = {
                "url": url,
                "css_selector": css_selector,
                "last_content_hash": "",
                "last_check": None,
                "change_count": 0
            }
            self.save_monitor_data()
            self.logger.info(f"已添加監(jiān)控網(wǎng)站: {name} - {url}")
        else:
            self.logger.warning(f"網(wǎng)站已存在: {name}")
    
    def remove_website(self, name):
        """
        移除監(jiān)控網(wǎng)站
        
        Args:
            name (str): 網(wǎng)站名稱
        """
        if name in self.monitor_data["websites"]:
            del self.monitor_data["websites"][name]
            self.save_monitor_data()
            self.logger.info(f"已移除監(jiān)控網(wǎng)站: {name}")
        else:
            self.logger.warning(f"網(wǎng)站不存在: {name}")
    
    def fetch_web_content(self, url, css_selector=None):
        """
        獲取網(wǎng)頁內(nèi)容
        
        Args:
            url (str): 網(wǎng)頁URL
            css_selector (str): CSS選擇器
            
        Returns:
            str: 網(wǎng)頁內(nèi)容
        """
        try:
            headers = {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
            }
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()
            
            if css_selector:
                soup = BeautifulSoup(response.content, 'html.parser')
                elements = soup.select(css_selector)
                content = "\n".join([elem.get_text(strip=True) for elem in elements])
            else:
                content = response.text
            
            return content
            
        except requests.RequestException as e:
            self.logger.error(f"獲取網(wǎng)頁內(nèi)容失敗 {url}: {str(e)}")
            return None
    
    def calculate_content_hash(self, content):
        """
        計(jì)算內(nèi)容哈希值
        
        Args:
            content (str): 內(nèi)容
            
        Returns:
            str: 哈希值
        """
        return hashlib.md5(content.encode('utf-8')).hexdigest()
    
    def check_website_changes(self):
        """
        檢查所有網(wǎng)站的內(nèi)容變化
        """
        self.logger.info("開始檢查網(wǎng)站內(nèi)容變化...")
        changes_detected = []
        
        for name, site_info in self.monitor_data["websites"].items():
            self.logger.info(f"檢查網(wǎng)站: {name}")
            
            content = self.fetch_web_content(site_info["url"], site_info["css_selector"])
            if content is None:
                continue
            
            current_hash = self.calculate_content_hash(content)
            last_hash = site_info["last_content_hash"]
            
            # 更新最后檢查時(shí)間
            site_info["last_check"] = datetime.now().isoformat()
            
            if last_hash and current_hash != last_hash:
                # 檢測到變化
                site_info["change_count"] += 1
                site_info["last_content_hash"] = current_hash
                
                change_info = {
                    "name": name,
                    "url": site_info["url"],
                    "timestamp": datetime.now().isoformat(),
                    "change_count": site_info["change_count"]
                }
                changes_detected.append(change_info)
                
                self.logger.info(f"檢測到變化: {name}")
                
                # 發(fā)送通知
                self.send_change_notification(change_info, content)
            
            elif not last_hash:
                # 第一次檢查，保存初始哈希
                site_info["last_content_hash"] = current_hash
                self.logger.info(f"初始監(jiān)控設(shè)置完成: {name}")
        
        # 保存更新后的數(shù)據(jù)
        self.save_monitor_data()
        
        if changes_detected:
            self.logger.info(f"檢測到 {len(changes_detected)} 個(gè)網(wǎng)站有變化")
        else:
            self.logger.info("未檢測到變化")
        
        return changes_detected
    
    def send_change_notification(self, change_info, new_content):
        """
        發(fā)送變化通知
        
        Args:
            change_info (dict): 變化信息
            new_content (str): 新內(nèi)容
        """
        try:
            email_config = self.monitor_data["email_config"]
            
            # 創(chuàng)建郵件內(nèi)容
            subject = f"網(wǎng)頁內(nèi)容變化通知 - {change_info['name']}"
            body = f"""
            檢測到網(wǎng)頁內(nèi)容發(fā)生變化：
            
            網(wǎng)站名稱: {change_info['name']}
            網(wǎng)址: {change_info['url']}
            變化時(shí)間: {change_info['timestamp']}
            變化次數(shù): {change_info['change_count']}
            
            新內(nèi)容預(yù)覽:
            {new_content[:500]}...
            
            ---
            此郵件由網(wǎng)頁內(nèi)容監(jiān)控器自動(dòng)發(fā)送
            """
            
            msg = MIMEText(body, 'plain', 'utf-8')
            msg['Subject'] = subject
            msg['From'] = email_config["sender_email"]
            msg['To'] = email_config["recipient_email"]
            
            # 發(fā)送郵件
            server = smtplib.SMTP(email_config["smtp_server"], email_config["smtp_port"])
            server.starttls()
            server.login(email_config["sender_email"], email_config["sender_password"])
            server.send_message(msg)
            server.quit()
            
            self.logger.info(f"變化通知已發(fā)送: {change_info['name']}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送通知失敗: {str(e)}")
    
    def start_monitoring(self):
        """開始定時(shí)監(jiān)控"""
        interval = self.monitor_data["check_interval"]
        
        self.logger.info(f"開始定時(shí)監(jiān)控，檢查間隔: {interval}秒")
        
        # 安排定時(shí)任務(wù)
        schedule.every(interval).seconds.do(self.check_website_changes)
        
        # 立即執(zhí)行一次檢查
        self.check_website_changes()
        
        # 保持程序運(yùn)行
        try:
            while True:
                schedule.run_pending()
                time.sleep(1)
        except KeyboardInterrupt:
            self.logger.info("監(jiān)控已停止")

# 使用示例
def demo_web_monitor():
    """演示網(wǎng)頁監(jiān)控器的使用"""
    monitor = WebContentMonitor()
    
    # 添加要監(jiān)控的網(wǎng)站
    monitor.add_website(
        "Python官網(wǎng)",
        "https://www.python.org",
        ".introduction"  # 只監(jiān)控介紹部分
    )
    
    monitor.add_website(
        "GitHub動(dòng)態(tài)",
        "https://github.com/trending",
        ".Box-row"  # 監(jiān)控趨勢項(xiàng)目
    )
    
    # 執(zhí)行一次檢查
    print("=== 執(zhí)行首次檢查 ===")
    changes = monitor.check_website_changes()
    
    if changes:
        print(f"檢測到 {len(changes)} 個(gè)變化:")
        for change in changes:
            print(f"  - {change['name']}: 第{change['change_count']}次變化")
    else:
        print("未檢測到變化")
    
    # 顯示監(jiān)控狀態(tài)
    print("\n=== 監(jiān)控狀態(tài) ===")
    for name, info in monitor.monitor_data["websites"].items():
        status = "已初始化" if info["last_content_hash"] else "待初始化"
        print(f"  {name}: {status}")

if __name__ == "__main__":
    demo_web_monitor()

import imaplib
import email
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import time
import re
import logging
from datetime import datetime
import json
from pathlib import Path

class AutoEmailResponder:
    """
    郵件自動(dòng)回復(fù)器
    自動(dòng)處理常見咨詢郵件并發(fā)送預(yù)設(shè)回復(fù)
    """
    
    def __init__(self, config_file="email_config.json"):
        """
        初始化自動(dòng)回復(fù)器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.config = self.load_config()
        self.setup_logging()
        self.processed_emails = set()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('auto_responder.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self):
        """
        加載配置
        
        Returns:
            dict: 配置信息
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "imap_server": "imap.example.com",
                "imap_port": 993,
                "smtp_server": "smtp.example.com",
                "smtp_port": 587,
                "email": "your_email@example.com",
                "password": "your_password",
                "check_interval": 300,
                "auto_replies": {
                    "price_inquiry": {
                        "keywords": ["價(jià)格", "多少錢", "報(bào)價(jià)", "cost", "price"],
                        "subject": "關(guān)于產(chǎn)品價(jià)格的回復(fù)",
                        "template": """尊敬的客戶，

感謝您對(duì)我們產(chǎn)品的關(guān)注。

我們的產(chǎn)品價(jià)格根據(jù)配置不同有所差異，具體如下：
- 基礎(chǔ)版: ￥999
- 專業(yè)版: ￥1999
- 企業(yè)版: ￥3999

如需詳細(xì)報(bào)價(jià)單，請(qǐng)告知您的具體需求。

祝好！
{company_name}團(tuán)隊(duì)"""
                    },
                    "technical_support": {
                        "keywords": ["問題", "錯(cuò)誤", "幫助", "怎么用", "problem", "error", "help"],
                        "subject": "技術(shù)支持回復(fù)",
                        "template": """尊敬的客戶，

感謝您聯(lián)系我們。

我們已經(jīng)收到您的技術(shù)咨詢，我們的技術(shù)支持團(tuán)隊(duì)將在24小時(shí)內(nèi)為您提供詳細(xì)解答。

常見問題解決方案可以參考我們的幫助文檔：
{help_url}

祝您使用愉快！
{company_name}技術(shù)支持團(tuán)隊(duì)"""
                    },
                    "general_inquiry": {
                        "keywords": ["咨詢", "了解", "信息", "inquiry", "information"],
                        "subject": "感謝您的咨詢",
                        "template": """尊敬的客戶，

感謝您對(duì)我們的關(guān)注和咨詢。

我們已經(jīng)收到您的消息，相關(guān)業(yè)務(wù)人員會(huì)盡快與您聯(lián)系，為您提供詳細(xì)的信息。

您也可以通過以下方式聯(lián)系我們：
- 電話：{phone}
- 官網(wǎng)：{website}

期待與您的合作！
{company_name}團(tuán)隊(duì)"""
                    }
                },
                "company_info": {
                    "company_name": "您的公司",
                    "phone": "400-123-4567",
                    "website": "https://www.example.com",
                    "help_url": "https://help.example.com"
                }
            }
            self.save_config(default_config)
            return default_config
    
    def save_config(self, config=None):
        """
        保存配置
        
        Args:
            config (dict): 配置信息
        """
        if config is None:
            config = self.config
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
    
    def connect_to_email(self):
        """
        連接到郵箱服務(wù)器
        
        Returns:
            tuple: (imap_connection, smtp_connection) 或 (None, None) 如果失敗
        """
        try:
            # 連接到IMAP服務(wù)器
            imap = imaplib.IMAP4_SSL(self.config["imap_server"], self.config["imap_port"])
            imap.login(self.config["email"], self.config["password"])
            
            # 連接到SMTP服務(wù)器
            smtp = smtplib.SMTP(self.config["smtp_server"], self.config["smtp_port"])
            smtp.starttls()
            smtp.login(self.config["email"], self.config["password"])
            
            self.logger.info("成功連接到郵箱服務(wù)器")
            return imap, smtp
            
        except Exception as e:
            self.logger.error(f"連接郵箱服務(wù)器失敗: {str(e)}")
            return None, None
    
    def classify_email(self, subject, body):
        """
        分類郵件內(nèi)容
        
        Args:
            subject (str): 郵件主題
            body (str): 郵件正文
            
        Returns:
            str: 郵件類型
        """
        content = (subject + " " + body).lower()
        
        for reply_type, reply_config in self.config["auto_replies"].items():
            for keyword in reply_config["keywords"]:
                if keyword.lower() in content:
                    return reply_type
        
        return "general_inquiry"  # 默認(rèn)回復(fù)類型
    
    def generate_reply(self, original_subject, reply_type, sender_name=""):
        """
        生成回復(fù)內(nèi)容
        
        Args:
            original_subject (str): 原始郵件主題
            reply_type (str): 回復(fù)類型
            sender_name (str): 發(fā)件人姓名
            
        Returns:
            tuple: (回復(fù)主題, 回復(fù)內(nèi)容)
        """
        if reply_type not in self.config["auto_replies"]:
            reply_type = "general_inquiry"
        
        reply_config = self.config["auto_replies"][reply_type]
        company_info = self.config["company_info"]
        
        # 個(gè)性化問候
        greeting = "尊敬的客戶"
        if sender_name:
            greeting = f"尊敬的{sender_name}"
        
        # 生成回復(fù)內(nèi)容
        template = reply_config["template"]
        reply_content = template.format(
            greeting=greeting,
            company_name=company_info["company_name"],
            phone=company_info["phone"],
            website=company_info["website"],
            help_url=company_info["help_url"]
        )
        
        # 生成回復(fù)主題
        reply_subject = f"Re: {original_subject}"
        if reply_config["subject"]:
            reply_subject = reply_config["subject"]
        
        return reply_subject, reply_content
    
    def extract_sender_name(self, from_header):
        """
        從發(fā)件人信息中提取姓名
        
        Args:
            from_header (str): 發(fā)件人頭信息
            
        Returns:
            str: 發(fā)件人姓名
        """
        # 簡單的姓名提取邏輯
        match = re.search(r'([^<]+)<', from_header)
        if match:
            name = match.group(1).strip().strip('"\'')
            if name:
                return name
        
        # 如果無法提取姓名，返回空字符串
        return ""
    
    def process_new_emails(self, imap, smtp):
        """
        處理新郵件
        
        Args:
            imap: IMAP連接
            smtp: SMTP連接
            
        Returns:
            int: 處理的郵件數(shù)量
        """
        try:
            # 選擇收件箱
            imap.select("INBOX")
            
            # 搜索未讀郵件
            status, messages = imap.search(None, 'UNSEEN')
            if status != 'OK':
                self.logger.warning("搜索郵件失敗")
                return 0
            
            email_ids = messages[0].split()
            processed_count = 0
            
            for email_id in email_ids:
                try:
                    # 獲取郵件內(nèi)容
                    status, msg_data = imap.fetch(email_id, '(RFC822)')
                    if status != 'OK':
                        continue
                    
                    raw_email = msg_data[0][1]
                    msg = email.message_from_bytes(raw_email)
                    
                    # 獲取郵件信息
                    subject = msg.get('Subject', '')
                    from_header = msg.get('From', '')
                    message_id = msg.get('Message-ID', '')
                    
                    # 跳過已處理的郵件
                    if message_id in self.processed_emails:
                        continue
                    
                    # 提取發(fā)件人姓名
                    sender_name = self.extract_sender_name(from_header)
                    
                    # 提取郵件正文
                    body = ""
                    if msg.is_multipart():
                        for part in msg.walk():
                            content_type = part.get_content_type()
                            content_disposition = str(part.get("Content-Disposition"))
                            
                            if content_type == "text/plain" and "attachment" not in content_disposition:
                                body = part.get_payload(decode=True).decode('utf-8', errors='ignore')
                                break
                    else:
                        body = msg.get_payload(decode=True).decode('utf-8', errors='ignore')
                    
                    # 分類郵件并生成回復(fù)
                    email_type = self.classify_email(subject, body)
                    reply_subject, reply_content = self.generate_reply(subject, email_type, sender_name)
                    
                    # 發(fā)送回復(fù)
                    self.send_reply(smtp, from_header, reply_subject, reply_content)
                    
                    # 標(biāo)記為已處理
                    self.processed_emails.add(message_id)
                    processed_count += 1
                    
                    self.logger.info(f"已處理郵件: {subject[:50]}...")
                    
                except Exception as e:
                    self.logger.error(f"處理郵件失敗 {email_id}: {str(e)}")
            
            return processed_count
            
        except Exception as e:
            self.logger.error(f"處理新郵件過程失敗: {str(e)}")
            return 0
    
    def send_reply(self, smtp, to_address, subject, content):
        """
        發(fā)送回復(fù)郵件
        
        Args:
            smtp: SMTP連接
            to_address (str): 收件人地址
            subject (str): 郵件主題
            content (str): 郵件內(nèi)容
        """
        try:
            msg = MIMEMultipart()
            msg['From'] = self.config["email"]
            msg['To'] = to_address
            msg['Subject'] = subject
            
            # 添加郵件正文
            msg.attach(MIMEText(content, 'plain', 'utf-8'))
            
            # 發(fā)送郵件
            smtp.send_message(msg)
            self.logger.info(f"已發(fā)送回復(fù)至: {to_address}")
            
        except Exception as e:
            self.logger.error(f"發(fā)送回復(fù)失敗: {str(e)}")
    
    def start_auto_responder(self):
        """啟動(dòng)自動(dòng)回復(fù)器"""
        self.logger.info("啟動(dòng)郵件自動(dòng)回復(fù)器")
        
        check_interval = self.config["check_interval"]
        
        while True:
            try:
                self.logger.info("檢查新郵件...")
                
                imap, smtp = self.connect_to_email()
                if imap and smtp:
                    processed = self.process_new_emails(imap, smtp)
                    self.logger.info(f"處理了 {processed} 封新郵件")
                    
                    # 關(guān)閉連接
                    imap.close()
                    imap.logout()
                    smtp.quit()
                
                # 等待下次檢查
                time.sleep(check_interval)
                
            except KeyboardInterrupt:
                self.logger.info("自動(dòng)回復(fù)器已停止")
                break
            except Exception as e:
                self.logger.error(f"自動(dòng)回復(fù)器運(yùn)行錯(cuò)誤: {str(e)}")
                time.sleep(check_interval)

# 使用示例
def demo_auto_responder():
    """演示自動(dòng)回復(fù)器的使用"""
    responder = AutoEmailResponder()
    
    print("=== 郵件自動(dòng)回復(fù)器配置 ===")
    print("當(dāng)前配置的自動(dòng)回復(fù)類型:")
    for reply_type, config in responder.config["auto_replies"].items():
        print(f"  {reply_type}: {len(config['keywords'])}個(gè)關(guān)鍵詞")
    
    print("\n公司信息:")
    for key, value in responder.config["company_info"].items():
        print(f"  {key}: {value}")
    
    print(f"\n檢查間隔: {responder.config['check_interval']}秒")
    
    # 注意：實(shí)際使用時(shí)需要先配置正確的郵箱信息
    print("\n注意：請(qǐng)先編輯 email_config.json 文件配置正確的郵箱信息")

if __name__ == "__main__":
    demo_auto_responder()

import psutil
import logging
import json
from datetime import datetime, timedelta
from pathlib import Path
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import schedule
import time

class SystemHealthMonitor:
    """
    系統(tǒng)健康監(jiān)控器
    監(jiān)控系統(tǒng)資源使用情況并生成健康報(bào)告
    """
    
    def __init__(self, config_file="system_monitor_config.json"):
        """
        初始化系統(tǒng)監(jiān)控器
        
        Args:
            config_file (str): 配置文件路徑
        """
        self.config_file = Path(config_file)
        self.config = self.load_config()
        self.health_data = []
        self.setup_logging()
    
    def setup_logging(self):
        """設(shè)置日志記錄"""
        logging.basicConfig(
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s',
            handlers=[
                logging.FileHandler('system_monitor.log'),
                logging.StreamHandler()
            ]
        )
        self.logger = logging.getLogger(__name__)
    
    def load_config(self):
        """
        加載配置
        
        Returns:
            dict: 配置信息
        """
        if self.config_file.exists():
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        else:
            # 默認(rèn)配置
            default_config = {
                "monitor_interval": 60,  # 監(jiān)控間隔（秒）
                "alert_thresholds": {
                    "cpu_percent": 80,
                    "memory_percent": 85,
                    "disk_percent": 90,
                    "temperature": 80
                },
                "report_interval": 3600,  # 報(bào)告間隔（秒）
                "email_alerts": {
                    "enabled": False,
                    "smtp_server": "smtp.example.com",
                    "smtp_port": 587,
                    "sender_email": "monitor@example.com",
                    "sender_password": "password",
                    "recipient_email": "admin@example.com"
                },
                "log_retention_days": 7
            }
            self.save_config(default_config)
            return default_config
    
    def save_config(self, config=None):
        """
        保存配置
        
        Args:
            config (dict): 配置信息
        """
        if config is None:
            config = self.config
        
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
    
    def collect_system_metrics(self):
        """
        收集系統(tǒng)指標(biāo)
        
        Returns:
            dict: 系統(tǒng)指標(biāo)數(shù)據(jù)
        """
        try:
            # CPU使用率
            cpu_percent = psutil.cpu_percent(interval=1)
            
            # 內(nèi)存使用情況
            memory = psutil.virtual_memory()
            
            # 磁盤使用情況
            disk = psutil.disk_usage('/')
            
            # 網(wǎng)絡(luò)IO
            net_io = psutil.net_io_counters()
            
            # 系統(tǒng)啟動(dòng)時(shí)間
            boot_time = datetime.fromtimestamp(psutil.boot_time())
            
            # 溫度信息（如果可用）
            try:
                temperatures = psutil.sensors_temperatures()
                if temperatures:
                    cpu_temp = temperatures.get('coretemp', [{}])[0].current if 'coretemp' in temperatures else None
                else:
                    cpu_temp = None
            except:
                cpu_temp = None
            
            metrics = {
                'timestamp': datetime.now().isoformat(),
                'cpu': {
                    'percent': cpu_percent,
                    'cores': psutil.cpu_count(),
                    'frequency': psutil.cpu_freq().current if psutil.cpu_freq() else None
                },
                'memory': {
                    'total': memory.total,
                    'available': memory.available,
                    'used': memory.used,
                    'percent': memory.percent
                },
                'disk': {
                    'total': disk.total,
                    'used': disk.used,
                    'free': disk.free,
                    'percent': disk.percent
                },
                'network': {
                    'bytes_sent': net_io.bytes_sent,
                    'bytes_recv': net_io.bytes_recv
                },
                'system': {
                    'boot_time': boot_time.isoformat(),
                    'temperature': cpu_temp
                }
            }
            
            return metrics
            
        except Exception as e:
            self.logger.error(f"收集系統(tǒng)指標(biāo)失敗: {str(e)}")
            return None
    
    def check_health_status(self, metrics):
        """
        檢查系統(tǒng)健康狀態(tài)
        
        Args:
            metrics (dict): 系統(tǒng)指標(biāo)
            
        Returns:
            dict: 健康狀態(tài)信息
        """
        alerts = []
        status = "healthy"
        
        thresholds = self.config["alert_thresholds"]
        
        # 檢查CPU使用率
        if metrics['cpu']['percent'] > thresholds['cpu_percent']:
            alerts.append(f"CPU使用率過高: {metrics['cpu']['percent']}%")
            status = "warning"
        
        # 檢查內(nèi)存使用率
        if metrics['memory']['percent'] > thresholds['memory_percent']:
            alerts.append(f"內(nèi)存使用率過高: {metrics['memory']['percent']}%")
            status = "warning"
        
        # 檢查磁盤使用率
        if metrics['disk']['percent'] > thresholds['disk_percent']:
            alerts.append(f"磁盤使用率過高: {metrics['disk']['percent']}%")
            status = "warning"
        
        # 檢查溫度
        if (metrics['system']['temperature'] and 
            metrics['system']['temperature'] > thresholds['temperature']):
            alerts.append(f"溫度過高: {metrics['system']['temperature']}°C")
            status = "critical"
        
        health_status = {
            'status': status,
            'alerts': alerts,
            'timestamp': metrics['timestamp']
        }
        
        return health_status
    
    def send_alert_email(self, health_status, metrics):
        """
        發(fā)送警報(bào)郵件
        
        Args:
            health_status (dict): 健康狀態(tài)
            metrics (dict): 系統(tǒng)指標(biāo)
        """
        if not self.config["email_alerts"]["enabled"]:
            return
        
        try:
            email_config = self.config["email_alerts"]
            
            # 創(chuàng)建郵件
            msg = MIMEMultipart()
            msg['From'] = email_config["sender_email"]
            msg['To'] = email_config["recipient_email"]
            msg['Subject'] = f"系統(tǒng)健康警報(bào) - {health_status['status'].upper()}"
            
            # 郵件正文
            body = f"""
系統(tǒng)健康監(jiān)控警報(bào)

狀態(tài): {health_status['status'].upper()}
時(shí)間: {health_status['timestamp']}

警報(bào)信息:
{chr(10).join(health_status['alerts'])}

系統(tǒng)指標(biāo)概覽:
- CPU使用率: {metrics['cpu']['percent']}%
- 內(nèi)存使用率: {metrics['memory']['percent']}%
- 磁盤使用率: {metrics['disk']['percent']}%
- 系統(tǒng)溫度: {metrics['system']['temperature'] or 'N/A'}°C

請(qǐng)及時(shí)檢查系統(tǒng)狀態(tài)。

---
此郵件由系統(tǒng)健康監(jiān)控器自動(dòng)發(fā)送
"""
            
            msg.attach(MIMEText(body, 'plain', 'utf-8'))
            
            # 發(fā)送郵件
            server = smtplib.SMTP(email_config["smtp_server"], email_config["smtp_port"])
            server.starttls()
            server.login(email_config["sender_email"], email_config["sender_password"])
            server.send_message(msg)
            server.quit()
            
            self.logger.info("警報(bào)郵件已發(fā)送")
            
        except Exception as e:
            self.logger.error(f"發(fā)送警報(bào)郵件失敗: {str(e)}")
    
    def generate_health_report(self, hours=24):
        """
        生成健康報(bào)告
        
        Args:
            hours (int): 報(bào)告覆蓋的小時(shí)數(shù)
            
        Returns:
            dict: 健康報(bào)告
        """
        # 過濾指定時(shí)間范圍內(nèi)的數(shù)據(jù)
        cutoff_time = datetime.now() - timedelta(hours=hours)
        recent_data = [
            data for data in self.health_data 
            if datetime.fromisoformat(data['timestamp']) > cutoff_time
        ]
        
        if not recent_data:
            return {"error": "沒有足夠的數(shù)據(jù)生成報(bào)告"}
        
        # 計(jì)算統(tǒng)計(jì)信息
        cpu_values = [data['metrics']['cpu']['percent'] for data in recent_data]
        memory_values = [data['metrics']['memory']['percent'] for data in recent_data]
        disk_values = [data['metrics']['disk']['percent'] for data in recent_data]
        
        report = {
            'report_time': datetime.now().isoformat(),
            'period_hours': hours,
            'data_points': len(recent_data),
            'summary': {
                'cpu': {
                    'average': sum(cpu_values) / len(cpu_values),
                    'max': max(cpu_values),
                    'min': min(cpu_values)
                },
                'memory': {
                    'average': sum(memory_values) / len(memory_values),
                    'max': max(memory_values),
                    'min': min(memory_values)
                },
                'disk': {
                    'average': sum(disk_values) / len(disk_values),
                    'max': max(disk_values),
                    'min': min(disk_values)
                }
            },
            'alerts_count': len([data for data in recent_data if data['health']['status'] != 'healthy']),
            'status_distribution': {
                'healthy': len([data for data in recent_data if data['health']['status'] == 'healthy']),
                'warning': len([data for data in recent_data if data['health']['status'] == 'warning']),
                'critical': len([data for data in recent_data if data['health']['status'] == 'critical'])
            }
        }
        
        return report
    
    def monitor_cycle(self):
        """執(zhí)行一次監(jiān)控循環(huán)"""
        self.logger.info("執(zhí)行系統(tǒng)健康檢查...")
        
        # 收集指標(biāo)
        metrics = self.collect_system_metrics()
        if not metrics:
            return
        
        # 檢查健康狀態(tài)
        health_status = self.check_health_status(metrics)
        
        # 存儲(chǔ)數(shù)據(jù)
        monitor_data = {
            'timestamp': datetime.now().isoformat(),
            'metrics': metrics,
            'health': health_status
        }
        self.health_data.append(monitor_data)
        
        # 清理舊數(shù)據(jù)
        retention_days = self.config.get("log_retention_days", 7)
        cutoff_time = datetime.now() - timedelta(days=retention_days)
        self.health_data = [
            data for data in self.health_data 
            if datetime.fromisoformat(data['timestamp']) > cutoff_time
        ]
        
        # 記錄狀態(tài)
        if health_status['status'] != 'healthy':
            self.logger.warning(f"系統(tǒng)狀態(tài): {health_status['status']} - {', '.join(health_status['alerts'])}")
            
            # 發(fā)送警報(bào)
            if health_status['status'] in ['warning', 'critical']:
                self.send_alert_email(health_status, metrics)
        else:
            self.logger.info("系統(tǒng)狀態(tài): 健康")
    
    def start_monitoring(self):
        """開始監(jiān)控"""
        self.logger.info("啟動(dòng)系統(tǒng)健康監(jiān)控器")
        
        interval = self.config["monitor_interval"]
        report_interval = self.config["report_interval"]
        
        # 安排監(jiān)控任務(wù)
        schedule.every(interval).seconds.do(self.monitor_cycle)
        
        # 安排報(bào)告任務(wù)
        schedule.every(report_interval).seconds.do(self.generate_daily_report)
        
        # 立即執(zhí)行一次監(jiān)控
        self.monitor_cycle()
        
        # 保持程序運(yùn)行
        try:
            while True:
                schedule.run_pending()
                time.sleep(1)
        except KeyboardInterrupt:
            self.logger.info("系統(tǒng)監(jiān)控已停止")
    
    def generate_daily_report(self):
        """生成每日?qǐng)?bào)告"""
        report = self.generate_health_report(24)
        
        # 保存報(bào)告到文件
        report_file = Path(f"system_health_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json")
        with open(report_file, 'w', encoding='utf-8') as f:
            json.dump(report, f, indent=2, ensure_ascii=False)
        
        self.logger.info(f"健康報(bào)告已生成: {report_file}")

# 使用示例
def demo_system_monitor():
    """演示系統(tǒng)監(jiān)控器的使用"""
    monitor = SystemHealthMonitor()
    
    print("=== 系統(tǒng)健康監(jiān)控器 ===")
    
    # 收集一次系統(tǒng)指標(biāo)
    metrics = monitor.collect_system_metrics()
    if metrics:
        print("\n當(dāng)前系統(tǒng)狀態(tài):")
        print(f"CPU使用率: {metrics['cpu']['percent']}%")
        print(f"內(nèi)存使用率: {metrics['memory']['percent']}%")
        print(f"磁盤使用率: {metrics['disk']['percent']}%")
        if metrics['system']['temperature']:
            print(f"CPU溫度: {metrics['system']['temperature']}°C")
        
        # 檢查健康狀態(tài)
        health_status = monitor.check_health_status(metrics)
        print(f"\n健康狀態(tài): {health_status['status']}")
        if health_status['alerts']:
            print("警報(bào):")
            for alert in health_status['alerts']:
                print(f"  - {alert}")
    
    print(f"\n監(jiān)控配置:")
    print(f"檢查間隔: {monitor.config['monitor_interval']}秒")
    print(f"報(bào)告間隔: {monitor.config['report_interval']}秒")
    print("警報(bào)閾值:")
    for metric, threshold in monitor.config['alert_thresholds'].items():
        print(f"  {metric}: {threshold}")

if __name__ == "__main__":
    demo_system_monitor()

"""
10個(gè)效率翻倍的Python自動(dòng)化腳本 - 完整代碼集合
作者: AI助手
日期: 2024年
"""

import os
import shutil
import logging
import pandas as pd
import numpy as np
import requests
from bs4 import BeautifulSoup
import hashlib
import time
import json
import smtplib
import imaplib
import email
import psutil
import schedule
from datetime import datetime, timedelta
from pathlib import Path
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email import encoders
import re

# 所有腳本的導(dǎo)入和類定義都在上面各節(jié)中提供
# 這里省略重復(fù)的代碼以節(jié)省空間

def main():
    """主函數(shù) - 演示所有腳本的使用"""
    print("=== Python自動(dòng)化腳本集合 ===")
    print("請(qǐng)選擇要演示的腳本:")
    print("1. 智能文件整理腳本")
    print("2. Excel報(bào)表自動(dòng)生成器")
    print("3. 網(wǎng)頁內(nèi)容監(jiān)控器")
    print("4. 郵件自動(dòng)回復(fù)器")
    print("5. 系統(tǒng)健康監(jiān)控器")
    print("6. 退出")
    
    while True:
        choice = input("\n請(qǐng)輸入選擇 (1-6): ").strip()
        
        if choice == '1':
            print("\n--- 智能文件整理腳本演示 ---")
            # 這里調(diào)用文件整理腳本的演示函數(shù)
            demo_file_organizer()
            
        elif choice == '2':
            print("\n--- Excel報(bào)表自動(dòng)生成器演示 ---")
            # 這里調(diào)用Excel報(bào)表生成器的演示函數(shù)
            demo_excel_reporter()
            
        elif choice == '3':
            print("\n--- 網(wǎng)頁內(nèi)容監(jiān)控器演示 ---")
            # 這里調(diào)用網(wǎng)頁監(jiān)控器的演示函數(shù)
            demo_web_monitor()
            
        elif choice == '4':
            print("\n--- 郵件自動(dòng)回復(fù)器演示 ---")
            # 這里調(diào)用郵件回復(fù)器的演示函數(shù)
            demo_auto_responder()
            
        elif choice == '5':
            print("\n--- 系統(tǒng)健康監(jiān)控器演示 ---")
            # 這里調(diào)用系統(tǒng)監(jiān)控器的演示函數(shù)
            demo_system_monitor()
            
        elif choice == '6':
            print("謝謝使用！")
            break
            
        else:
            print("無效選擇，請(qǐng)重新輸入。")

if __name__ == "__main__":
    main()