【Agent从入门到实践】18 脚本化编程：批量执行、自动化逻辑

人工智能AI技术2026-01-22 11:11

文章目录

目前国内还是很缺AI人才的，希望更多人能真正加入到AI行业，共同促进行业进步。想要系统学习AI知识的朋友可以看看我的教程http://blog.csdn.net/jiangjunshow，教程通俗易懂，风趣幽默，从深度学习基础原理到各领域实战应用都有讲解。

前言

各位AI入门的小伙伴们，前面咱们搞定了Agent的"信息交互"（HTTP/API）和"信息处理"（JSON/CSV解析），现在Agent已经能"看懂"外部数据、"听懂"用户需求了！但还有个关键能力没解锁------Agent怎么"自动干活"？

比如：

  • 每天早上8点自动查天气，给用户发穿衣提醒；
  • 批量处理100个Excel文件，提取关键数据生成报告；
  • 当库存低于阈值时，自动给供应商发补货通知；
  • 每隔1小时检查订单状态，给用户推送物流更新。

这些"重复、有规律、需要定时/批量执行"的任务，正是脚本化编程的强项------而这也和Agent的"执行能力"完美契合！今天咱们就聊聊脚本化编程怎么让Agent从"被动响应"变成"主动干活"，全程大白话+最新Python实战，只讲Agent开发用得上的自动化技巧！

一、先搞懂：脚本化编程到底是什么？（人话版）

脚本化编程 = 写一段"自动执行的代码脚本"，让电脑按规则完成重复任务

你可以把它理解成：给Agent写的"操作手册" ------明确告诉Agent"什么时候做、做什么、怎么做"，不需要人工干预，Agent就能自动执行。

生活里的类比：

  • 洗衣机的"标准洗涤程序"：按一下按钮，自动完成"加水→洗涤→漂洗→脱水"；
  • 手机的"闹钟"：每天固定时间自动响铃；
  • 外卖App的"催单提醒"：下单30分钟未接单，自动发送提醒。

对Agent来说：

  • 脚本化编程 = Agent的"自动化执行引擎"；
  • 核心价值：批量处理重复任务、定时执行规律任务、按条件触发任务，解放人工，提高执行效率。

脚本化编程与Agent执行能力的3个核心契合点

  1. 批量执行 ↔ Agent的"多任务处理"：Agent需要同时处理多个用户需求、多个文件、多个API请求，脚本化能高效批量完成；
  2. 自动化逻辑 ↔ Agent的"自主决策执行"：Agent根据决策结果自动执行动作，脚本化提供了"if-else/循环"的逻辑框架；
  3. 无人工干预 ↔ Agent的"自主工作能力"：Agent的终极目标是"自主完成任务"，脚本化让它不用依赖人工触发，能主动干活。

一句话：脚本化编程是Agent执行能力的"放大器"------让Agent的执行更高效、更自主、更能扛事儿 。

二、Python脚本化编程：3个核心技术（Agent开发必备）

Python是脚本化编程的"首选语言"（和Agent开发不谋而合），核心原因是：语法简洁、生态丰富、能快速实现自动化逻辑。以下3个技术是Agent脚本化的基础，必须掌握！

1. 批量处理：循环+列表推导式（高效处理多个任务）

批量处理是脚本化的核心------比如批量处理文件、批量调用API、批量发送消息。Python的"for循环"和"列表推导式"是批量处理的利器，尤其是列表推导式，简洁又高效（比传统for循环快30%+）。

实战1：批量调用API（查询多个城市天气）

场景：Agent需要查询10个城市的天气，生成批量报告。

python 复制代码 
import httpx
import json

# 要查询的城市列表（批量任务）
cities = ["北京", "上海", "广州", "深圳", "杭州", "成都", "武汉", "西安", "南京", "重庆"]
weather_api_key = "你的天气API密钥"
base_url = "https://api.openweathermap.org/data/2.5/weather"

# 批量调用API（用列表推导式+for循环，简洁高效）
def batch_get_weather(cities: list) -> list:
    weather_results = []
    # 用httpx.Client复用连接，比单次创建快很多（2025年推荐用法）
    with httpx.Client(timeout=10) as client:
        for city in cities:
            params = {
                "q": city,
                "appid": weather_api_key,
                "units": "metric",
                "lang": "zh_cn"
            }
            try:
                response = client.get(base_url, params=params)
                response.raise_for_status()
                data = response.json()
                # 提取关键信息（结构化处理）
                weather_info = {
                    "city": data["name"],
                    "temperature": data["main"]["temp"],
                    "humidity": data["main"]["humidity"],
                    "desc": data["weather"][0]["description"]
                }
                weather_results.append(weather_info)
            except Exception as e:
                weather_results.append({"city": city, "error": str(e)})
    return weather_results

# 执行批量任务
if __name__ == "__main__":
    results = batch_get_weather(cities)
    # 批量输出结果
    for res in results:
        if "error" not in res:
            print(f"{res['city']}：温度{res['temperature']}℃，湿度{res['humidity']}%，{res['desc']}")
        else:
            print(f"{res['city']}：查询失败 - {res['error']}")
实战2：批量处理文件（读取多个CSV并合并）

场景：Agent需要读取10个订单CSV文件，合并成一个总表。

python 复制代码 
import pandas as pd
from pathlib import Path  # Python 3.12+优化版，替代os.path，更简洁

# 批量读取文件夹下的所有CSV文件
def batch_merge_csv(folder_path: str) -> pd.DataFrame:
    # 获取文件夹下所有.csv文件（pathlib2特性，2025年推荐）
    csv_files = list(Path(folder_path).glob("*.csv"))
    if not csv_files:
        raise ValueError("文件夹中没有CSV文件")
    
    # 批量读取并合并（列表推导式，比for循环简洁）
    df_list = [pd.read_csv(file, encoding="utf-8-sig") for file in csv_files]
    merged_df = pd.concat(df_list, ignore_index=True)  # 合并所有DataFrame
    
    return merged_df

# 执行批量任务
if __name__ == "__main__":
    folder = "订单文件文件夹"
    merged_df = batch_merge_csv(folder)
    # 保存合并结果
    merged_df.to_csv("合并后的订单总表.csv", index=False, encoding="utf-8-sig")
    print(f"批量处理完成！共合并{len(merged_df)}条订单记录")
    print(f"合并文件已保存到：合并后的订单总表.csv")

2. 自动化逻辑：条件判断+异常处理（让脚本"容错"又"智能"）

自动化脚本不能"一根筋"------需要根据不同情况做不同处理（条件判断），还要能处理错误（异常处理），否则很容易中途崩溃。这和Agent的"决策执行"逻辑完全一致：Agent根据决策结果（条件）执行不同动作，遇到错误（如API调用失败）能自动重试/上报。

实战：带条件判断+异常处理的库存补货脚本

场景：Agent监控库存CSV文件，当某类原料库存低于阈值时，自动发送补货通知（模拟调用API）。

python 复制代码 
import pandas as pd
import httpx
from datetime import datetime

# 库存阈值配置（Agent的决策规则）
STOCK_THRESHOLD = {
    "珍珠": 20,
    "椰果": 15,
    "芋圆": 10,
    "脆波波": 12
}

# 补货通知API（模拟）
REPLENISH_API = "https://api.example.com/replenish"
API_KEY = "你的补货API密钥"

def auto_replenish_stock(stock_file: str):
    try:
        # 读取库存数据
        df_stock = pd.read_csv(stock_file, encoding="utf-8-sig")
        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 开始监控库存...")
        
        # 遍历库存，判断是否需要补货（条件判断）
        for _, row in df_stock.iterrows():
            material = row["material"]
            current_stock = row["current_stock"]
            
            # 条件1：原料在阈值配置中
            if material not in STOCK_THRESHOLD:
                continue
            
            # 条件2：当前库存低于阈值
            if current_stock < STOCK_THRESHOLD[material]:
                need = STOCK_THRESHOLD[material] * 2  # 补货量=阈值的2倍
                print(f"⚠️ {material}库存不足：当前{current_stock}，阈值{STOCK_THRESHOLD[material]}，需补货{need}")
                
                # 调用补货API（自动化执行）
                headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
                payload = {
                    "material": material,
                    "need_quantity": need,
                    "current_quantity": current_stock,
                    "timestamp": datetime.now().isoformat()
                }
                
                with httpx.Client(timeout=15) as client:
                    response = client.post(REPLENISH_API, headers=headers, json=payload)
                    response.raise_for_status()
                    result = response.json()
                    if result["success"]:
                        print(f"✅ {material}补货请求发送成功，订单号：{result['order_id']}")
                    else:
                        print(f"❌ {material}补货请求失败：{result['msg']}")
        
        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 库存监控完成\n")
    
    # 异常处理：文件读取失败
    except FileNotFoundError:
        print(f"❌ 库存文件不存在：{stock_file}")
    # 异常处理：API调用失败
    except httpx.HTTPError as e:
        print(f"❌ 补货API调用失败：{str(e)}")
    # 其他异常
    except Exception as e:
        print(f"❌ 脚本执行异常：{str(e)}")

# 执行自动化脚本
if __name__ == "__main__":
    auto_replenish_stock("库存表.csv")

3. 定时执行：schedule3（让脚本按时间自动运行）

很多Agent任务需要"定时执行"------比如每天早上查天气、每小时检查库存、每周生成报告。Python的schedule3库（2025年最新稳定版，比旧版schedule性能提升50%+）能轻松实现定时逻辑，语法简单，不用写复杂的定时器。

实战：定时执行的天气提醒脚本

场景：Agent每天早上7:30自动查询天气，给用户发送穿衣提醒（模拟发送短信）。

python 复制代码 
import schedule
import time
import httpx
from datetime import datetime

# 天气API配置
WEATHER_API = "https://api.openweathermap.org/data/2.5/weather"
WEATHER_API_KEY = "你的天气API密钥"
CITY = "北京"
# 短信通知API（模拟）
SMS_API = "https://api.example.com/send_sms"
SMS_API_KEY = "你的短信API密钥"
USER_PHONE = "13800138000"

def get_weather() -> dict:
    """获取天气数据"""
    params = {
        "q": CITY,
        "appid": WEATHER_API_KEY,
        "units": "metric",
        "lang": "zh_cn"
    }
    with httpx.Client(timeout=10) as client:
        response = client.get(WEATHER_API, params=params)
        response.raise_for_status()
        data = response.json()
        return {
            "temp": data["main"]["temp"],
            "desc": data["weather"][0]["description"],
            "humidity": data["main"]["humidity"]
        }

def send_weather_reminder():
    """发送天气提醒"""
    try:
        weather = get_weather()
        temp = weather["temp"]
        desc = weather["desc"]
        
        # 生成提醒文案（Agent的执行结果输出）
        if temp > 28:
            reminder = f"【早安天气提醒】北京今日{desc}，温度{temp}℃，炎热注意防暑，建议穿短袖、多喝水～"
        elif 15 <= temp <= 28:
            reminder = f"【早安天气提醒】北京今日{desc}，温度{temp}℃，天气舒适，建议穿薄外套～"
        else:
            reminder = f"【早安天气提醒】北京今日{desc}，温度{temp}℃，天气较凉，建议穿厚外套、注意保暖～"
        
        print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 发送提醒：{reminder}")
        
        # 调用短信API发送提醒（自动化执行）
        headers = {"Authorization": f"Bearer {SMS_API_KEY}", "Content-Type": "application/json"}
        payload = {
            "phone": USER_PHONE,
            "content": reminder,
            "timestamp": datetime.now().isoformat()
        }
        
        with httpx.Client(timeout=15) as client:
            response = client.post(SMS_API, headers=headers, json=payload)
            response.raise_for_status()
            result = response.json()
            if result["success"]:
                print(f"✅ 提醒发送成功，短信ID：{result['sms_id']}\n")
            else:
                print(f"❌ 提醒发送失败：{result['msg']}\n")
    
    except Exception as e:
        print(f"❌ 天气提醒执行失败：{str(e)}\n")

def run_scheduled_script():
    """启动定时任务"""
    # 每天早上7:30执行（schedule3的简洁语法）
    schedule.every().day.at("07:30").do(send_weather_reminder)
    print(f"定时脚本已启动，每天07:30自动发送天气提醒...")
    
    # 循环监听任务（保持脚本运行）
    while True:
        schedule.run_pending()
        time.sleep(60)  # 每60秒检查一次

# 启动定时脚本
if __name__ == "__main__":
    run_scheduled_script()

关键结论：

  • 批量处理→ 用for循环+列表推导式+httpx.Client复用连接；
  • 自动化逻辑→ 用if-else条件判断+try-except异常处理；
  • 定时执行→ 用schedule3库，语法简洁、性能稳定。

三、脚本化编程与Agent执行模块的深度整合（完整实战）

咱们把脚本化编程和Agent的"执行模块"结合起来，实现一个"智能订单处理Agent"------具备批量处理订单、自动库存扣减、定时生成报告的完整能力。

python 复制代码 
import pandas as pd
import httpx
import schedule
import time
from pathlib import Path
from datetime import datetime

# 配置信息（Agent的配置记忆）
CONFIG = {
    "order_folder": "新订单文件夹",
    "stock_file": "库存表.csv",
    "report_folder": "订单报告文件夹",
    "weather_api_key": "你的天气API密钥",
    "city": "北京",
    "stock_threshold": {"珍珠": 20, "椰果": 15, "芋圆": 10, "脆波波": 12}
}

# 确保报告文件夹存在
Path(CONFIG["report_folder"]).mkdir(exist_ok=True)

class OrderProcessingAgent:
    def __init__(self):
        self.weather_data = None  # 存储天气数据（感知模块结果）
    
    def get_weather(self):
        """感知模块：获取天气数据"""
        try:
            params = {
                "q": CONFIG["city"],
                "appid": CONFIG["weather_api_key"],
                "units": "metric",
                "lang": "zh_cn"
            }
            with httpx.Client(timeout=10) as client:
                response = client.get("https://api.openweathermap.org/data/2.5/weather", params=params)
                response.raise_for_status()
                data = response.json()
                self.weather_data = {
                    "temp": data["main"]["temp"],
                    "desc": data["weather"][0]["description"]
                }
                print(f"✅ 天气数据获取成功：{self.weather_data}")
        except Exception as e:
            print(f"❌ 天气数据获取失败：{str(e)}")
            self.weather_data = {"temp": 25, "desc": "未知"}  # 默认值
    
    def batch_process_orders(self):
        """执行模块：批量处理新订单"""
        print(f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 开始批量处理订单...")
        try:
            # 1. 批量读取新订单文件
            order_files = list(Path(CONFIG["order_folder"]).glob("*.csv"))
            if not order_files:
                print("⚠️  没有新订单文件")
                return
            
            # 2. 合并订单数据
            df_orders = pd.concat([pd.read_csv(f, encoding="utf-8-sig") for f in order_files], ignore_index=True)
            print(f"📦 共读取{len(order_files)}个订单文件，{len(df_orders)}条订单记录")
            
            # 3. 读取当前库存
            df_stock = pd.read_csv(CONFIG["stock_file"], encoding="utf-8-sig")
            stock_dict = dict(zip(df_stock["material"], df_stock["current_stock"]))
            
            # 4. 批量处理每个订单（扣减库存）
            successful_orders = []
            failed_orders = []
            
            for _, order in df_orders.iterrows():
                order_id = order["order_id"]
                flavor = order["flavor"]
                quantity = order["quantity"]
                topping = flavor.split("+")[-1]  # 提取配料（如"三分糖+珍珠"→"珍珠"）
                
                # 条件判断：库存是否充足
                if topping not in stock_dict:
                    failed_orders.append({"order_id": order_id, "reason": f"配料{topping}不存在"})
                    continue
                
                if stock_dict[topping] < quantity:
                    failed_orders.append({"order_id": order_id, "reason": f"{topping}库存不足（当前{stock_dict[topping]}，需{quantity}）"})
                    continue
                
                # 扣减库存
                stock_dict[topping] -= quantity
                successful_orders.append(order_id)
                print(f"✅ 订单{order_id}处理成功：扣减{topping}×{quantity}，剩余{stock_dict[topping]}")
            
            # 5. 更新库存文件
            df_stock["current_stock"] = df_stock["material"].map(stock_dict)
            df_stock.to_csv(CONFIG["stock_file"], index=False, encoding="utf-8-sig")
            
            # 6. 生成处理报告
            report = {
                "处理时间": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "处理订单数": len(df_orders),
                "成功订单数": len(successful_orders),
                "失败订单数": len(failed_orders),
                "失败订单": failed_orders,
                "天气情况": self.weather_data
            }
            
            # 保存报告
            report_df = pd.DataFrame([report])
            report_file = Path(CONFIG["report_folder"]) / f"订单处理报告_{datetime.now().strftime('%Y%m%d%H%M%S')}.csv"
            report_df.to_csv(report_file, index=False, encoding="utf-8-sig")
            
            print(f"\n📊 订单处理完成：")
            print(f"   - 成功：{len(successful_orders)}条")
            print(f"   - 失败：{len(failed_orders)}条")
            print(f"   - 报告已保存：{report_file.name}")
        
        except Exception as e:
            print(f"❌ 批量处理订单失败：{str(e)}")
    
    def scheduled_task(self):
        """定时任务：每天10点执行订单处理"""
        # 先获取天气数据（感知）
        self.get_weather()
        # 再批量处理订单（执行）
        self.batch_process_orders()
    
    def start(self):
        """启动Agent：启动定时任务"""
        print("🚀 智能订单处理Agent已启动...")
        # 每天10:00执行定时任务
        schedule.every().day.at("10:00").do(self.scheduled_task)
        
        # 循环监听
        while True:
            schedule.run_pending()
            time.sleep(60)

# 启动Agent
if __name__ == "__main__":
    agent = OrderProcessingAgent()
    agent.start()

运行效果：

复制代码 
🚀 智能订单处理Agent已启动...
✅ 天气数据获取成功：{'temp': 28, 'desc': '晴'}

[2025-08-02 10:00:00] 开始批量处理订单...
📦 共读取3个订单文件，15条订单记录
✅ 订单ORDER001处理成功：扣减珍珠×2，剩余48
✅ 订单ORDER002处理成功：扣减椰果×1，剩余29
...
📊 订单处理完成：
   - 成功：13条
   - 失败：2条
   - 报告已保存：订单处理报告_20250802100030.csv

这个实战案例完美体现了脚本化编程与Agent执行能力的契合：

  • 批量处理：一次性处理多个订单文件，高效；
  • 自动化逻辑：根据库存状态自动判断订单是否可执行，智能；
  • 定时执行：每天固定时间自动运行，自主；
  • 整合感知：先获取天气数据，为后续决策（如推荐冰度）做准备。

四、脚本化编程的5个最佳实践（Agent开发避坑指南）

1. 配置与代码分离

  • 不要把API密钥、文件路径硬编码在脚本里，用python-dotenv管理环境变量：

    python 复制代码 
    # .env文件
WEATHER_API_KEY=sk-xxxxxx
STOCK_THRESHOLD_PEARL=20

# 脚本中读取
from dotenv import load_dotenv
import os
load_dotenv()
api_key = os.getenv("WEATHER_API_KEY")

2. 日志替代print（便于调试）

  • 用Python内置的logging模块，代替print，支持输出到文件、分级（INFO/WARNING/ERROR）：

    python 复制代码 
    import logging
logging.basicConfig(
    filename="agent.log",
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s"
)
logging.info("Agent启动成功")
logging.error("订单处理失败：库存不足")

3. 幂等性设计（避免重复执行问题）

  • 脚本重复执行时，不会产生副作用（比如重复扣减库存）：
    • 订单处理后，给文件重命名（如ORDER001.csv→ORDER001_已处理.csv）；
    • 数据库中记录订单状态，避免重复处理。

4. 资源释放（避免文件占用）

  • 用with语句管理文件、网络连接，自动释放资源：

    python 复制代码 
    # 正确：with语句自动关闭文件
with open("订单.csv", "r", encoding="utf-8") as f:
    data = f.read()

# 正确：with语句自动关闭HTTP连接
with httpx.Client() as client:
    client.get(url)

5. 批量任务分片（处理大量数据时）

  • 当批量处理10000+条数据时，分片处理，避免内存溢出：

    python 复制代码 
    # 分片处理10000条订单，每次处理1000条
total_orders = len(df_orders)
batch_size = 1000
for i in range(0, total_orders, batch_size):
    batch_df = df_orders[i:i+batch_size]
    # 处理当前分片...
    print(f"处理分片{i//batch_size+1}：{len(batch_df)}条订单")

五、总结：脚本化编程让Agent"更能打"的核心逻辑

其实脚本化编程与Agent执行能力的契合点，本质上是"用代码自动化解决重复、有规律的问题"------这正是Agent的核心价值之一：替代人工完成繁琐的重复性工作。

对Agent开发来说，脚本化编程的核心作用：

  1. 提升执行效率：批量处理任务，比单个执行快10倍+；
  2. 增强自主性：定时/条件触发任务，不用人工干预；
  3. 提高稳定性：脚本逻辑固定，减少人为错误；
  4. 降低维护成本：统一的脚本框架，便于修改和扩展。

学会脚本化编程后，你的Agent能从"被动响应用户需求"升级为"主动发现问题、解决问题"：

  • 从"用户让查天气才查"变成"每天自动查天气发提醒"；
  • 从"用户让处理订单才处理"变成"每天自动处理新订单"；
  • 从"用户让查库存才查"变成"库存不足自动补货"。

如果觉得这篇文章好懂、实用，别忘了点赞、转发，让更多人一起入门AI～ 有任何问题，评论区留言交流呀！

相关推荐
摘星编程2 小时前
React Native + OpenHarmony：MapView自定义标注样式
python
向量引擎2 小时前
[硬核架构] 2026 企业级 AI 网关落地指南：从“连接超时”到“秒级响应”的架构演进（附 Python/Java 源码）
人工智能·python·gpt·ai作画·架构·aigc·api调用
0思必得02 小时前
[Web自动化] Selenium模拟用户的常见操作
前端·python·selenium·自动化
Aloudata2 小时前
数据语义层 vs 宽表模式：哪种架构更适合 AI 时代的数据分析？
人工智能·架构·数据挖掘·数据分析·数据治理
凡客丶2 小时前
Windows版Miniconda打包环境迁移到内网离线环境【详解】
windows·python
OLOLOadsd1232 小时前
基于改进YOLOv13的长曲棍球角色识别与装备检测系统
人工智能·yolo·目标跟踪
高频交易dragon2 小时前
An Impulse Control Approach to Market Making in a Hawkes LOB Market从论文到生产
人工智能·算法·机器学习
AI营销快线2 小时前
原圈科技AI CRM系统打破数据孤岛，实现业绩增长的可视化闘环
大数据·人工智能
AI大佬的小弟2 小时前
【详细步骤】大模型基础知识（4）---ollama模型调用-多轮对话体验
python·ollama·大模型基础·ai 聊天机器人·简单的大模型部署·实现ollama模型调用·零基础上手 ollama体验
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）04AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南052025 Telegram 最新免费社工库机器人（LetsTG可[特殊字符]）搭建指南（含 Python 脚本）06UV安装并设置国内源07BongoCat - 跨平台键盘猫动画工具08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09Linux下V2Ray安装配置指南10Claude Code Skills 实用使用手册