Python脚本化编程与Agent自动化开发实践

1. 脚本化编程的本质与Agent执行能力

在AI开发领域，脚本化编程是指通过编写可自动执行的代码脚本，让计算机按照预设规则完成特定任务的技术手段。这种编程方式特别适合处理那些重复性高、规律性强且需要定时或批量执行的工作场景。

1.1 脚本化编程的三大核心特征

1. 自动化执行：脚本能够在无人干预的情况下自动运行，完成既定任务
2. 批量处理能力：可以同时处理多个相似任务，大幅提升工作效率
3. 条件触发机制：能够根据预设条件自动触发特定操作

1.2 Agent与脚本化编程的天然契合点

1. 任务自动化：Agent需要持续监控环境并自动响应，这与脚本的自动化特性完美匹配
2. 批量处理需求：Agent经常需要同时处理多个相似请求或数据
3. 条件触发机制：Agent的决策过程本质上就是基于条件的自动化响应

提示：在Agent开发中，脚本化编程不是可选项而是必选项。一个没有脚本化能力的Agent就像没有手脚的人，能思考但无法行动。

2. Python脚本化编程核心技术

2.1 批量处理技术

2.1.1 循环与列表推导式

python复制# 传统循环方式
results = []
for item in item_list:
    results.append(process_item(item))

# 列表推导式
results = [process_item(item) for item in item_list]

2.1.2 实战案例：批量API调用

python复制import requests

cities = ['北京', '上海', '广州', '深圳']
weather_data = {}

for city in cities:
    response = requests.get(f'https://api.weather.com/v1/city/{city}/current')
    weather_data[city] = response.json()

# 使用map函数实现并行处理
import concurrent.futures
with concurrent.futures.ThreadPoolExecutor() as executor:
    weather_data = dict(zip(cities, executor.map(get_weather, cities)))

2.1.3 实战案例：批量文件处理

python复制import pandas as pd
import glob

# 读取并合并多个CSV文件
all_files = glob.glob('data/*.csv')
df_list = []

for filename in all_files:
    df = pd.read_csv(filename)
    df_list.append(df)

combined_df = pd.concat(df_list, ignore_index=True)

# 使用列表推导式简化
combined_df = pd.concat([pd.read_csv(f) for f in glob.glob('data/*.csv')])

2.2 自动化逻辑实现

2.2.1 条件判断与异常处理

python复制def check_inventory(item_id, threshold=10):
    try:
        current_stock = get_inventory(item_id)
        if current_stock < threshold:
            place_order(item_id, threshold - current_stock)
            log_action(f"Replenishment order placed for {item_id}")
            return True
        return False
    except Exception as e:
        log_error(f"Inventory check failed for {item_id}: {str(e)}")
        return False

2.2.2 实战案例：智能库存补货系统

python复制class InventoryManager:
    def __init__(self):
        self.thresholds = self.load_thresholds()
    
    def check_and_replenish(self):
        for item_id, threshold in self.thresholds.items():
            try:
                current = self.get_current_stock(item_id)
                if current < threshold:
                    self.place_order(item_id, threshold - current)
            except ConnectionError:
                self.retry_later(item_id)
            except Exception as e:
                self.log_exception(e)
    
    def place_order(self, item_id, quantity):
        # 实现订单放置逻辑
        pass

2.3 定时执行技术

2.3.1 使用schedule库

python复制import schedule
import time

def send_weather_alert():
    # 获取天气数据并发送提醒的逻辑
    pass

# 设置定时任务
schedule.every().day.at("08:00").do(send_weather_alert)

while True:
    schedule.run_pending()
    time.sleep(60)  # 每分钟检查一次

2.3.2 实战案例：天气提醒服务

python复制import schedule
import requests
import smtplib
from email.message import EmailMessage

def get_weather(city):
    # 实现天气API调用
    pass

def send_email(to, subject, content):
    # 实现邮件发送逻辑
    pass

def daily_weather_report():
    cities = ['北京', '上海', '广州']
    report = []
    
    for city in cities:
        weather = get_weather(city)
        report.append(f"{city}: {weather['condition']}, 温度{weather['temp']}℃")
    
    send_email(
        "user@example.com",
        "每日天气早报",
        "\n".join(report)
    )

# 设置每天早上7:30发送
schedule.every().day.at("07:30").do(daily_weather_report)

# 保持程序运行
while True:
    schedule.run_pending()
    time.sleep(60)

3. 脚本化编程与Agent的深度整合

3.1 Agent执行模块设计

python复制class TaskScheduler:
    def __init__(self):
        self.tasks = []
    
    def add_task(self, task_func, schedule_rule):
        self.tasks.append({
            'func': task_func,
            'rule': schedule_rule
        })
    
    def run(self):
        while True:
            for task in self.tasks:
                if task['rule'].should_run():
                    try:
                        task['func']()
                    except Exception as e:
                        self.handle_error(e)
            time.sleep(1)

class WeatherMonitoringAgent:
    def __init__(self):
        self.scheduler = TaskScheduler()
        self.setup_tasks()
    
    def setup_tasks(self):
        self.scheduler.add_task(
            self.check_weather,
            DailyRule(at_time="08:00")
        )
    
    def check_weather(self):
        # 天气检查逻辑
        pass

3.2 完整整合案例

python复制class SmartAgent:
    def __init__(self):
        self.inventory_manager = InventoryManager()
        self.weather_monitor = WeatherMonitor()
        self.task_scheduler = TaskScheduler()
        
        self.setup_schedules()
    
    def setup_schedules(self):
        # 库存检查每小时执行一次
        self.task_scheduler.add_task(
            self.inventory_manager.check_all,
            IntervalRule(hours=1)
        )
        
        # 天气提醒每天早晨执行
        self.task_scheduler.add_task(
            self.weather_monitor.daily_report,
            DailyRule(at_time="07:30")
        )
    
    def run(self):
        self.task_scheduler.run()

4. 脚本化编程最佳实践

4.1 配置与代码分离

python复制# config.yaml
inventory:
  thresholds:
    item1: 20
    item2: 15
  suppliers:
    item1: supplierA
    item2: supplierB

weather:
  cities: [北京, 上海, 广州]
  recipients: [user1@example.com, user2@example.com]

python复制import yaml

with open('config.yaml') as f:
    config = yaml.safe_load(f)

thresholds = config['inventory']['thresholds']

4.2 完善的日志系统

python复制import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='agent.log'
)

logger = logging.getLogger('InventoryAgent')

try:
    check_inventory()
except Exception as e:
    logger.error(f"Inventory check failed: {str(e)}")

4.3 幂等性设计

python复制def process_order(order_id):
    if is_order_processed(order_id):
        logger.info(f"Order {order_id} already processed")
        return
    
    # 处理订单逻辑
    mark_order_processed(order_id)

4.4 资源管理

python复制def process_files(file_list):
    for file_path in file_list:
        try:
            with open(file_path, 'r') as f:
                data = f.read()
                process_data(data)
        except IOError as e:
            logger.error(f"Failed to process {file_path}: {str(e)}")
        finally:
            if 'f' in locals() and not f.closed:
                f.close()

4.5 批量任务分片处理

python复制from itertools import islice

def batch_process(items, batch_size=100):
    iterator = iter(items)
    while True:
        batch = list(islice(iterator, batch_size))
        if not batch:
            break
        process_batch(batch)
        time.sleep(1)  # 避免资源耗尽

5. 性能优化技巧

5.1 并行处理技术

python复制from concurrent.futures import ThreadPoolExecutor

def process_all_cities(cities):
    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(get_weather, cities))
    return results

5.2 内存优化

python复制import pandas as pd

def process_large_csv(file_path):
    # 分块读取大文件
    for chunk in pd.read_csv(file_path, chunksize=10000):
        process_chunk(chunk)

5.3 错误重试机制

python复制from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def call_unreliable_api():
    response = requests.get('https://unreliable-api.example.com')
    response.raise_for_status()
    return response.json()

6. 实际应用场景扩展

6.1 电商价格监控Agent

python复制class PriceMonitor:
    def __init__(self):
        self.products = self.load_products()
        self.price_history = {}
    
    def check_prices(self):
        for product in self.products:
            current_price = self.get_current_price(product['id'])
            if current_price < product['alert_price']:
                self.send_alert(product, current_price)
    
    def send_alert(self, product, price):
        # 发送价格提醒
        pass

6.2 智能家居控制Agent

python复制class HomeAutomationAgent:
    def __init__(self):
        self.schedule = {
            'morning': {'lights': 'on', 'thermostat': 22},
            'night': {'lights': 'off', 'thermostat': 18}
        }
    
    def run_schedule(self, schedule_name):
        actions = self.schedule.get(schedule_name, {})
        for device, setting in actions.items():
            self.control_device(device, setting)
    
    def control_device(self, device, setting):
        # 控制智能家居设备
        pass

在长期开发自动化Agent的过程中，我发现脚本化编程最容易被忽视的是异常处理和日志记录。很多开发者把主要精力放在核心逻辑上，但当脚本在无人值守环境下运行时，完善的错误处理和日志系统才是保证长期稳定运行的关键。建议在项目初期就建立规范的日志系统和错误处理机制，这会为后期的维护和调试节省大量时间。