我是指导专家，不是娱乐信息查询助手。请提供您想创作标题的关键词，我将为您打造一个通俗易懂、符合事实且吸引人的标题。

引言：为什么需要自动化？

在当今快节奏的数字时代，我们每天都会重复执行许多相同的任务：整理文件、处理数据、发送邮件、备份文件等。这些任务虽然简单，但累积起来会消耗大量时间。Python作为一门简洁而强大的编程语言，提供了丰富的库和工具，可以帮助我们自动化这些重复性工作，让我们专注于更有创造性的任务。

自动化不仅能节省时间，还能减少人为错误，提高工作效率。想象一下，你不再需要每周手动整理下载文件夹，不再需要逐个复制备份重要文件，也不需要手动从网站抓取数据——所有这些都可以通过几行Python代码自动完成。

本文将带你从零开始学习如何使用Python自动化日常任务，包括文件操作、网络爬虫、邮件发送、定时任务等实用技能。无论你是编程新手还是有一定经验的开发者，都能从中获得实用的知识和技巧。

1. Python自动化基础：环境准备

1.1 安装Python

首先，确保你的电脑上安装了Python。建议安装Python 3.7或更高版本。你可以从Python官网下载最新版本。

安装时，请务必勾选”Add Python to PATH”选项，这样可以在命令行中直接使用python命令。

1.2 验证安装

打开命令行（Windows: cmd或PowerShell；Mac/Linux: Terminal），输入：

python --version

如果显示版本号，说明安装成功。

1.3 安装必要的库

我们将使用一些标准库和第三方库：

pip install requests beautifulsoup4 pandas openpyxl schedule smtplib email

这些库分别用于：

requests: 发送HTTP请求
beautifulsoup4: 解析HTML
pandas: 数据处理
openpyxl: 操作Excel
schedule: 定时任务
smtplib: 发送邮件
email: 构建邮件内容

2. 文件和目录自动化

2.1 基础文件操作

Python内置的os和shutil模块提供了强大的文件操作功能。

示例：自动整理下载文件夹

import os
import shutil
from pathlib import Path

def organize_downloads():
    # 定义下载目录和目标目录
    downloads = Path.home() / "Downloads"
    targets = {
        "Images": [".jpg", ".png", ".gif", ".jpeg"],
        "Documents": [".pdf", ".docx", ".txt", ".xlsx"],
        "Videos": [".mp4", ".mov", ".avi"],
        "Music": [".mp3", ".wav", ".flac"],
        "Archives": [".zip", ".rar", ".7z", ".tar"]
    }
    
    # 创建目标文件夹（如果不存在）
    for folder in targets:
        (downloads / folder).mkdir(exist_ok=True)
    
    # 遍历下载目录中的所有文件
    for file in downloads.iterdir():
        if file.is_file():
            moved = False
            # 检查文件扩展名并移动到对应文件夹
            for folder, extensions in targets.items():
                if file.suffix.lower() in extensions:
                    shutil.move(str(file), str(downloads / folder / file.name))
                    moved = True
                    print(f"已移动: {file.name} -> {folder}/")
                    break
            
            # 如果没有匹配的类别，移动到"Others"文件夹
            if not moved:
                others_folder = downloads / "Others"
                others_folder.mkdir(exist_ok=True)
                shutil.move(str(file), str(others_folder / file.name))
                print(f"已移动: {file.name} -> Others/")

# 运行函数
organize_downloads()

代码说明：

使用pathlib模块处理路径，比传统的字符串拼接更安全
定义了不同文件类型对应的目标文件夹
遍历下载目录中的所有文件
根据文件扩展名移动到对应文件夹
无法识别的文件移动到”Others”文件夹

2.2 批量重命名文件

import os
from datetime import datetime

def batch_rename(directory, prefix="file"):
    """
    批量重命名指定目录下的所有文件
    格式: prefix_YYYYMMDD_序号.扩展名
    """
    if not os.path.exists(directory):
        print(f"目录不存在: {directory}")
        return
    
    files = [f for f in os.listdir(directory) 
             if os.path.isfile(os.path.join(directory, f))]
    
    if not files:
        print("目录中没有文件")
        return
    
    today = datetime.now().strftime("%Y%m%d")
    counter = 1
    
    for filename in files:
        # 获取文件扩展名
        name, ext = os.path.splitext(filename)
        
        # 构建新文件名
        new_name = f"{prefix}_{today}_{counter:03d}{ext}"
        
        # 重命名
        old_path = os.path.join(directory, filename)
        new_path = os.path.join(directory, new_name)
        
        try:
            os.rename(old_path, new_path)
            print(f"重命名: {filename} -> {new_name}")
            counter += 1
        except Exception as e:
            print(f"重命名失败 {filename}: {e}")

# 使用示例
batch_rename("/path/to/your/directory", "photo")

2.3 自动备份重要文件

import shutil
import datetime
import os

def backup_files(source_dir, backup_dir):
    """
    自动备份文件到带时间戳的目录
    """
    # 创建备份目录（如果不存在）
    if not os.path.exists(backup_dir):
        os.makedirs(backup_dir)
    
    # 生成时间戳
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_path = os.path.join(backup_dir, f"backup_{timestamp}")
    
    try:
        # 复制整个目录
        shutil.copytree(source_dir, backup_path)
        print(f"备份成功: {source_dir} -> {backup_path}")
        
        # 可选：删除旧备份（保留最近5个）
        backups = sorted([d for d in os.listdir(backup_dir) 
                         if d.startswith("backup_")])
        if len(backups) > 5:
            for old_backup in backups[:-5]:
                old_path = os.path.join(backup_dir, old_backup)
                shutil.rmtree(old_path)
                print(f"删除旧备份: {old_backup}")
                
    except Exception as e:
        print(f"备份失败: {e}")

# 使用示例
backup_files("/path/to/important/files", "/path/to/backup/location")

3. 网络自动化

3.1 网页数据抓取

使用requests和BeautifulSoup可以轻松抓取网页内容。

示例：抓取天气信息

import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime

def scrape_weather(city="beijing"):
    """
    从天气网站抓取天气预报数据
    """
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
    
    url = f"https://www.weather.com.cn/weather/{city}.shtml"
    
    try:
        response = requests.get(url, headers=headers, timeout=10)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # 查找天气预报数据（根据实际网页结构调整）
        forecast = []
        weather_items = soup.find_all('ul', class_='t clearfix')
        
        for item in weather_items:
            dates = item.find_all('h1')
            temps = item.find_all('p', class_='tem')
            conditions = item.find_all('p', class_='wea')
            
            for date, temp, cond in zip(dates, temps, conditions):
                forecast.append({
                    '日期': date.get_text(),
                    '天气': cond.get_text(),
                    '温度': temp.get_text(),
                    '抓取时间': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                })
        
        # 保存到CSV
        filename = f"weather_{city}_{datetime.now().strftime('%Y%m%d')}.csv"
        with open(filename, 'w', newline='', encoding='utf-8-sig') as f:
            writer = csv.DictWriter(f, fieldnames=['日期', '天气', '温度', '抓取时间'])
            writer.writeheader()
            writer.writerows(forecast)
        
        print(f"天气数据已保存到 {filename}")
        return forecast
        
    except Exception as e:
        print(f"抓取失败: {e}")
        return []

# 使用示例
weather_data = scrape_weather("101010100")  # 北京的代码
for day in weather_data:
    print(day)

3.2 自动登录网站

import requests
from bs4 import BeautifulSoup

def auto_login(url, username, password):
    """
    自动登录网站（需要根据具体网站调整）
    """
    session = requests.Session()
    
    # 首先获取登录页面，提取CSRF token等隐藏字段
    login_page = session.get(url)
    soup = BeautifulSoup(login_page.text, 'html.parser')
    
    # 查找登录表单（需要根据实际网页结构调整）
    form = soup.find('form')
    if not form:
        print("未找到登录表单")
        return None
    
    # 构建POST数据
    login_data = {
        'username': username,
        'password': password,
    }
    
    # 添加其他隐藏字段
    for hidden in form.find_all('input', type='hidden'):
        login_data[hidden.get('name')] = hidden.get('value')
    
    # 发送登录请求
    login_url = url  # 可能需要调整为实际的登录处理URL
    response = session.post(login_url, data=login_data)
    
    # 检查登录是否成功
    if "登录成功" in response.text or "dashboard" in response.url:
        print("登录成功！")
        return session
    else:
        print("登录失败")
        return None

# 使用示例（注意：这只是一个通用模板，实际使用时需要根据具体网站调整）
# session = auto_login("https://example.com/login", "your_username", "your_password")

4. 数据处理自动化

4.1 Excel自动化

使用openpyxl库可以读写Excel文件。

示例：合并多个Excel文件

import pandas as pd
import glob
import os

def merge_excel_files(input_folder, output_file):
    """
    合并文件夹中所有Excel文件到一个文件
    """
    # 查找所有Excel文件
    excel_files = glob.glob(os.path.join(input_folder, "*.xlsx"))
    
    if not excel_files:
        print("未找到Excel文件")
        return
    
    all_data = []
    
    for file in excel_files:
        try:
            # 读取Excel文件
            df = pd.read_excel(file)
            # 添加来源文件名
            df['来源文件'] = os.path.basename(file)
            all_data.append(df)
            print(f"已读取: {os.path.basename(file)}")
        except Exception as e:
            print(f"读取失败 {file}: {e}")
    
    if all_data:
        # 合并所有数据
        merged_df = pd.concat(all_data, ignore_index=True)
        
        # 保存合并后的文件
        merged_df.to_excel(output_file, index=False)
        print(f"合并完成，共{len(merged_df)}行数据，保存为: {output_file}")

# 使用示例
merge_excel_files("/path/to/excel/files", "/path/to/merged_file.xlsx")

4.2 CSV数据处理

import csv
from collections import defaultdict

def analyze_csv_data(csv_file):
    """
    分析CSV文件并生成统计报告
    """
    if not os.path.exists(csv_file):
        print(f"文件不存在: {csv_file}")
        return
    
    data = defaultdict(list)
    total_rows = 0
    
    try:
        with open(csv_file, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            
            for row in reader:
                total_rows += 1
                for key, value in row.items():
                    data[key].append(value)
        
        # 生成统计报告
        report = []
        report.append(f"CSV文件分析报告: {csv_file}")
        report.append("=" * 50)
        report.append(f"总行数: {total_rows}")
        report.append(f"列数: {len(data)}")
        report.append("\n各列统计:")
        
        for column, values in data.items():
            unique_count = len(set(values))
            report.append(f"  {column}:")
            report.append(f"    - 唯一值数量: {unique_count}")
            report.append(f"    - 缺失值数量: {values.count('')}")
            
            # 如果是数值列，计算基本统计
            try:
                numeric_values = [float(v) for v in values if v.strip()]
                if numeric_values:
                    report.append(f"    - 最小值: {min(numeric_values)}")
                    report.append(f"    - 最大值: {max(numeric_values)}")
                    report.append(f"    - 平均值: {sum(numeric_values)/len(numeric_values):.2f}")
            except ValueError:
                pass
        
        # 保存报告
        report_file = csv_file.replace('.csv', '_analysis.txt')
        with open(report_file, 'w', encoding='utf-8') as f:
            f.write('\n'.join(report))
        
        print('\n'.join(report))
        print(f"\n报告已保存到: {report_file}")
        
    except Exception as e:
        print(f"分析失败: {e}")

# 使用示例
analyze_csv_data("/path/to/your/data.csv")

5. 邮件自动化

5.1 发送简单邮件

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header
import datetime

def send_email(subject, body, to_emails, from_email, password, smtp_server, smtp_port=587):
    """
    发送邮件的通用函数
    """
    try:
        # 创建邮件对象
        msg = MIMEMultipart()
        msg['From'] = from_email
        msg['To'] = ', '.join(to_emails)
        msg['Subject'] = Header(subject, 'utf-8')
        
        # 添加邮件正文
        msg.attach(MIMEText(body, 'plain', 'utf-8'))
        
        # 连接SMTP服务器并发送
        server = smtplib.SMTP(smtp_server, smtp_port)
        server.starttls()  # 启用加密
        server.login(from_email, password)
        server.send_message(msg)
        server.quit()
        
        print(f"邮件已发送至: {to_emails}")
        return True
        
    except Exception as e:
        print(f"邮件发送失败: {e}")
        return False

# 使用示例
if __name__ == "__main__":
    # 邮件配置（请使用实际的邮箱信息）
    EMAIL_CONFIG = {
        'from': 'your_email@gmail.com',
        'password': 'your_app_password',  # 对于Gmail，需要使用应用专用密码
        'smtp_server': 'smtp.gmail.com',
        'smtp_port': 587
    }
    
    # 发送邮件
    subject = "每日报告 - " + datetime.datetime.now().strftime("%Y-%m-%d")
    body = """
    这是今天的自动化报告。
    
    包含以下内容：
    1. 文件整理完成
    2. 数据备份成功
    3. 网络数据抓取完成
    
    此邮件由Python脚本自动发送。
    """
    
    send_email(
        subject=subject,
        body=body,
        to_emails=['recipient@example.com'],
        from_email=EMAIL_CONFIG['from'],
        password=EMAIL_CONFIG['password'],
        smtp_server=EMAIL_CONFIG['smtp_server'],
        smtp_port=EMAIL_CONFIG['smtp_port']
    )

5.2 发送带附件的邮件

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from email.header import Header

def send_email_with_attachment(subject, body, to_emails, attachment_path, 
                               from_email, password, smtp_server, smtp_port=587):
    """
    发送带附件的邮件
    """
    try:
        # 创建邮件对象
        msg = MIMEMultipart()
        msg['From'] = from_email
        msg['To'] = ', '.join(to_emails)
        msg['Subject'] = Header(subject, 'utf-8')
        
        # 添加邮件正文
        msg.attach(MIMEText(body, 'plain', 'utf-8'))
        
        # 添加附件
        with open(attachment_path, 'rb') as f:
            attachment = MIMEApplication(f.read())
            attachment.add_header('Content-Disposition', 'attachment', 
                                 filename=os.path.basename(attachment_path))
            msg.attach(attachment)
        
        # 连接SMTP服务器并发送
        server = smtplib.SMTP(smtp_server, smtp_port)
        server.starttls()
        server.login(from_email, password)
        server.send_message(msg)
        server.quit()
        
        print(f"带附件的邮件已发送至: {to_emails}")
        return True
        
    except Exception as e:
        print(f"邮件发送失败: {e}")
        return False

# 使用示例
if __name__ == "__main__":
    # 配置信息
    EMAIL_CONFIG = {
        'from': 'your_email@gmail.com',
        'password': 'your_app_password',
        'smtp_server': 'smtp.gmail.com',
        'smtp_port': 587
    }
    
    # 发送带附件的邮件
    send_email_with_attachment(
        subject="周报附件 - " + datetime.datetime.now().strftime("%Y-%m-%d"),
        body="请查收本周的自动化报告附件。",
        to_emails=['recipient@example.com'],
        attachment_path="/path/to/your/report.pdf",
        from_email=EMAIL_CONFIG['from'],
        password=EMAIL_CONFIG['password'],
        smtp_server=EMAIL_CONFIG['smtp_server'],
        smtp_port=EMAIL_CONFIG['smtp_port']
    )

6. 定时任务自动化

6.1 使用schedule库

import schedule
import time
import datetime

def job_function():
    """要执行的任务"""
    print(f"任务执行时间: {datetime.datetime.now()}")
    # 这里可以调用之前定义的任何自动化函数
    # 例如：organize_downloads(), backup_files()等

def schedule_tasks():
    """设置定时任务"""
    
    # 每天早上9点执行
    schedule.every().day.at("09:00").do(job_function)
    
    # 每周一早上9点执行
    schedule.every().monday.at("09:00").do(job_function)
    
    # 每5分钟执行一次
    schedule.every(5).minutes.do(job_function)
    
    # 每小时执行一次
    schedule.every().hour.do(job_function)
    
    # 每隔10秒执行一次（用于测试）
    schedule.every(10).seconds.do(job_function)
    
    print("定时任务已启动，按Ctrl+C退出")
    
    # 保持程序运行
    while True:
        schedule.run_pending()
        time.sleep(1)

# 使用示例
if __name__ == "__main__":
    schedule_tasks()

6.2 使用系统定时任务

对于Windows和Linux/Mac，可以使用系统级的定时任务：

Windows任务计划程序：

# 创建一个批处理文件（.bat）来运行Python脚本
# 文件名: run_automation.bat
"""
@echo off
cd /d C:\path\to\your\script
python automation_script.py
"""

# 然后在任务计划程序中设置定时运行这个批处理文件

Linux/Mac Crontab：

# 编辑crontab
# crontab -e

# 添加以下行（每天早上9点运行）
# 0 9 * * * /usr/bin/python3 /path/to/your/automation_script.py

# 每5分钟运行一次
# */5 * * * * /usr/bin/python3 /path/to/your/automation_script.py

7. 实战案例：完整的自动化工作流

7.1 每日数据抓取和报告生成系统

import requests
from bs4 import BeautifulSoup
import pandas as pd
import datetime
import os
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.application import MIMEApplication
import schedule
import time

class DailyAutomationSystem:
    def __init__(self, config):
        self.config = config
        self.data_dir = config.get('data_dir', './daily_data')
        self.reports_dir = config.get('reports_dir', './reports')
        
        # 创建目录
        os.makedirs(self.data_dir, exist_ok=True)
        os.makedirs(self.reports_dir, exist_ok=True)
    
    def fetch_data(self):
        """抓取数据"""
        print(f"[{datetime.datetime.now()}] 开始抓取数据...")
        
        # 示例：抓取股票数据（需要根据实际网站调整）
        try:
            # 这里使用一个示例URL，实际使用时需要替换
            url = "https://example.com/market-data"
            headers = {"User-Agent": "Mozilla/5.0"}
            
            response = requests.get(url, headers=headers, timeout=30)
            response.raise_for_status()
            
            soup = BeautifulSoup(response.text, 'html.parser')
            
            # 解析数据（示例结构）
            data = []
            # 假设数据在table中
            table = soup.find('table')
            if table:
                for row in table.find_all('tr')[1:]:  # 跳过表头
                    cols = row.find_all('td')
                    if len(cols) >= 3:
                        data.append({
                            '时间': datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                            '名称': cols[0].get_text().strip(),
                            '数值': cols[1].get_text().strip(),
                            '变化': cols[2].get_text().strip()
                        })
            
            # 保存数据
            if data:
                df = pd.DataFrame(data)
                filename = f"market_data_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
                filepath = os.path.join(self.data_dir, filename)
                df.to_csv(filepath, index=False, encoding='utf-8-sig')
                print(f"数据已保存: {filepath}")
                return filepath
            else:
                print("未抓取到数据")
                return None
                
        except Exception as e:
            print(f"数据抓取失败: {e}")
            return None
    
    def generate_report(self, data_file):
        """生成报告"""
        print(f"[{datetime.datetime.now()}] 开始生成报告...")
        
        if not data_file or not os.path.exists(data_file):
            print("数据文件不存在")
            return None
        
        try:
            # 读取数据
            df = pd.read_csv(data_file)
            
            # 生成报告内容
            report_content = []
            report_content.append("=" * 60)
            report_content.append(f"每日数据报告 - {datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}")
            report_content.append("=" * 60)
            report_content.append("")
            
            # 基本统计
            report_content.append("数据概览:")
            report_content.append(f"  - 总记录数: {len(df)}")
            report_content.append(f"  - 数据时间: {df['时间'].min()} 至 {df['时间'].max()}")
            report_content.append("")
            
            # 详细数据
            report_content.append("详细数据:")
            for _, row in df.iterrows():
                report_content.append(f"  {row['名称']}: {row['数值']} ({row['变化']})")
            
            report_content.append("")
            report_content.append("=" * 60)
            report_content.append("报告生成时间: " + datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
            
            # 保存报告
            report_filename = f"report_{datetime.datetime.now().strftime('%Y%m%d')}.txt"
            report_path = os.path.join(self.reports_dir, report_filename)
            
            with open(report_path, 'w', encoding='utf-8') as f:
                f.write('\n'.join(report_content))
            
            print(f"报告已生成: {report_path}")
            return report_path
            
        except Exception as e:
            print(f"报告生成失败: {e}")
            return None
    
    def send_report(self, report_file, data_file=None):
        """发送报告邮件"""
        print(f"[{datetime.datetime.now()}] 开始发送邮件...")
        
        if not report_file or not os.path.exists(report_file):
            print("报告文件不存在")
            return False
        
        try:
            # 读取报告内容
            with open(report_file, 'r', encoding='utf-8') as f:
                report_body = f.read()
            
            # 创建邮件
            msg = MIMEMultipart()
            msg['From'] = self.config['email_from']
            msg['To'] = ', '.join(self.config['email_to'])
            msg['Subject'] = f"每日数据报告 - {datetime.datetime.now().strftime('%Y-%m-%d')}"
            
            # 添加正文
            msg.attach(MIMEText(report_body, 'plain', 'utf-8'))
            
            # 添加报告附件
            with open(report_file, 'rb') as f:
                attachment = MIMEApplication(f.read())
                attachment.add_header('Content-Disposition', 'attachment', 
                                     filename=os.path.basename(report_file))
                msg.attach(attachment)
            
            # 添加数据文件附件（如果有）
            if data_file and os.path.exists(data_file):
                with open(data_file, 'rb') as f:
                    attachment = MIMEApplication(f.read())
                    attachment.add_header('Content-Disposition', 'attachment', 
                                         filename=os.path.basename(data_file))
                    msg.attach(attachment)
            
            # 发送邮件
            server = smtplib.SMTP(self.config['smtp_server'], self.config['smtp_port'])
            server.starttls()
            server.login(self.config['email_from'], self.config['email_password'])
            server.send_message(msg)
            server.quit()
            
            print(f"邮件已发送至: {self.config['email_to']}")
            return True
            
        except Exception as e:
            print(f"邮件发送失败: {e}")
            return False
    
    def run_daily(self):
        """运行每日自动化流程"""
        print(f"\n{'='*60}")
        print(f"开始执行每日自动化流程 - {datetime.datetime.now()}")
        print(f"{'='*60}\n")
        
        # 1. 抓取数据
        data_file = self.fetch_data()
        
        if data_file:
            # 2. 生成报告
            report_file = self.generate_report(data_file)
            
            if report_file:
                # 3. 发送邮件
                self.send_report(report_file, data_file)
        
        print(f"\n{'='*60}")
        print(f"自动化流程执行完成 - {datetime.datetime.now()}")
        print(f"{'='*60}\n")

def main():
    # 配置信息
    config = {
        'data_dir': './daily_data',
        'reports_dir': './reports',
        'email_from': 'your_email@gmail.com',
        'email_to': ['recipient@example.com'],
        'email_password': 'your_app_password',
        'smtp_server': 'smtp.gmail.com',
        'smtp_port': 587
    }
    
    # 创建自动化系统实例
    automation_system = DailyAutomationSystem(config)
    
    # 设置定时任务（每天早上9点执行）
    schedule.every().day.at("09:00").do(automation_system.run_daily)
    
    # 立即执行一次（用于测试）
    print("立即执行一次测试...")
    automation_system.run_daily()
    
    # 保持程序运行
    print("\n定时任务已启动，等待执行...")
    while True:
        schedule.run_pending()
        time.sleep(60)  # 每分钟检查一次

if __name__ == "__main__":
    main()

8. 错误处理和日志记录

8.1 添加日志记录

import logging
import os
from datetime import datetime

def setup_logging():
    """设置日志记录"""
    # 创建日志目录
    log_dir = "logs"
    os.makedirs(log_dir, exist_ok=True)
    
    # 日志文件名（带日期）
    log_file = os.path.join(log_dir, f"automation_{datetime.now().strftime('%Y%m%d')}.log")
    
    # 配置日志格式
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler(log_file, encoding='utf-8'),
            logging.StreamHandler()  # 同时输出到控制台
        ]
    )
    
    return logging.getLogger(__name__)

# 使用日志
logger = setup_logging()

def safe_operation(func):
    """装饰器：安全执行函数并记录日志"""
    def wrapper(*args, **kwargs):
        try:
            logger.info(f"开始执行: {func.__name__}")
            result = func(*args, **kwargs)
            logger.info(f"执行成功: {func.__name__}")
            return result
        except Exception as e:
            logger.error(f"执行失败 {func.__name__}: {e}", exc_info=True)
            return None
    return wrapper

# 示例：使用装饰器
@safe_operation
def risky_operation():
    # 可能会失败的操作
    import random
    if random.random() < 0.5:
        raise ValueError("随机错误")
    return "成功"

# 测试
for i in range(5):
    risky_operation()

9. 最佳实践和注意事项

9.1 安全性考虑

不要硬编码密码：使用环境变量或配置文件
使用应用专用密码：对于Gmail等服务
限制权限：只授予必要的权限
错误处理：不要暴露敏感信息

import os
from dotenv import load_dotenv

# 使用环境变量存储敏感信息
load_dotenv()

EMAIL_PASSWORD = os.getenv('EMAIL_PASSWORD')
if not EMAIL_PASSWORD:
    raise ValueError("请设置EMAIL_PASSWORD环境变量")

9.2 性能优化

批量操作：减少I/O操作次数
使用生成器：处理大数据集
缓存结果：避免重复计算
多线程/多进程：并行处理

import concurrent.futures
import time

def process_file(filename):
    """处理单个文件"""
    time.sleep(1)  # 模拟耗时操作
    return f"处理完成: {filename}"

def parallel_processing(file_list):
    """并行处理文件"""
    with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(process_file, file_list))
    return results

# 使用示例
files = [f"file_{i}.txt" for i in range(10)]
results = parallel_processing(files)
print(results)

9.3 可维护性

模块化设计：将功能拆分成独立函数
配置文件：使用JSON/YAML存储配置
文档注释：为函数和类添加说明
版本控制：使用Git管理代码

# 配置文件示例（config.json）
"""
{
    "email": {
        "from": "your_email@gmail.com",
        "to": ["recipient@example.com"],
        "smtp_server": "smtp.gmail.com",
        "smtp_port": 587
    },
    "paths": {
        "data_dir": "./data",
        "backup_dir": "./backup"
    },
    "schedule": {
        "daily": "09:00",
        "weekly": "monday 09:00"
    }
}
"""

import json

def load_config(config_file="config.json"):
    """加载配置文件"""
    with open(config_file, 'r', encoding='utf-8') as f:
        return json.load(f)

# 使用配置
config = load_config()
print(config['email']['from'])

10. 总结

Python自动化是一个强大的工具，可以帮助我们节省大量时间并减少错误。通过本文介绍的技能，你可以：

自动化文件管理：整理、备份、重命名文件
网络数据抓取：自动获取网页信息
数据处理：处理Excel、CSV等数据文件
邮件自动化：自动发送报告和通知
定时任务：让自动化流程在指定时间运行
错误处理：确保自动化流程的稳定性

下一步建议

从简单开始：先实现一个简单的自动化任务
逐步扩展：在成功的基础上添加更多功能
学习调试：掌握Python调试技巧
加入社区：参与Python自动化相关的论坛和群组
持续学习：关注新的库和工具

记住，自动化的目的是让生活更轻松，而不是更复杂。选择那些真正重复且耗时的任务进行自动化，你会惊讶于它能为你节省多少时间！

附录：常用Python自动化库速查表

库名称	用途	安装命令
os/shutil	文件操作	内置
pathlib	路径处理	内置
requests	HTTP请求	pip install requests
beautifulsoup4	HTML解析	pip install beautifulsoup4
pandas	数据处理	pip install pandas
openpyxl	Excel操作	pip install openpyxl
schedule	定时任务	pip install schedule
smtplib	邮件发送	内置
selenium	浏览器自动化	pip install selenium
pyautogui	GUI自动化	pip install pyautogui
watchdog	文件监控	pip install watchdog

希望这篇文章能帮助你开启Python自动化之旅！如果有任何问题，欢迎继续探索和学习。# 如何利用Python自动化日常任务：从入门到实践的完整指南