from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

X, y = load_iris(return_X_y=True)                    # 经典鸢尾花数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.2, random_state=42)

model = RandomForestClassifier(n_estimators=100).fit(X_train, y_train)
print(accuracy_score(y_test, model.predict(X_test)))  # 1.0

import torch
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 1. 数据：自动下载 MNIST，归一化
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((.1307,), (.3081,))])
train_set = datasets.MNIST("./data", train=True, download=True, transform=transform)
test_set  = datasets.MNIST("./data", train=False, transform=transform)
train_loader = DataLoader(train_set, batch_size=64, shuffle=True)
test_loader  = DataLoader(test_set, batch_size=256)

# 2. 模型：两个卷积块 + 全连接分类头
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, 3, padding=1), nn.ReLU(),   # 28×28 → 28×28×32
            nn.MaxPool2d(2),                              # → 14×14×32
            nn.Conv2d(32, 64, 3, padding=1), nn.ReLU(),   # → 14×14×64
            nn.MaxPool2d(2),                              # → 7×7×64
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64 * 7 * 7, 128), nn.ReLU(),
            nn.Dropout(.25),
            nn.Linear(128, 10),                           # 0~9 十类
        )

    def forward(self, x):
        return self.classifier(self.features(x))

device = "cuda" if torch.cuda.is_available() else "cpu"
model = CNN().to(device)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

# 3. 训练
for epoch in range(3):
    model.train()
    for x, y in train_loader:
        x, y = x.to(device), y.to(device)
        optimizer.zero_grad()
        loss = criterion(model(x), y)
        loss.backward()          # 反向传播
        optimizer.step()         # 更新权重
    print(f"epoch {epoch + 1} done, loss={loss.item():.4f}")

# 4. 测试
model.eval()
correct = total = 0
with torch.no_grad():            # 推理不需要梯度
    for x, y in test_loader:
        pred = model(x.to(device)).argmax(1).cpu()
        correct += (pred == y).sum().item()
        total += len(y)
print(f"测试集准确率: {correct / total:.2%}")    # 约 99%

name = "Tom"          # str 字符串
age = 30              # int 整数
height = 1.75         # float 浮点数
active = True         # bool 布尔值（注意大写开头）
nothing = None        # NoneType 空值

# type() 查看类型
print(type(age))      # <class 'int'>

# 类型转换
n = int("42")         # str -> int
s = str(3.14)         # float -> str

s = "Hello, Python"

# f-string 格式化（推荐，3.6+）
lang = "Python"
print(f"我在学 {lang}，今年是 {2026} 年")

# 常用方法
print(s.lower())          # 转小写
print(s.split(", "))      # 切分 -> ['Hello', 'Python']
print(s.replace("Hello", "Hi"))
print("  pad  ".strip())  # 去首尾空白
print(len(s))             # 长度
print("Py" in s)          # 包含判断 -> True

# 多行字符串
text = """第一行
第二行"""

a, b = 10, 3
print(a + b, a / b, a // b)   # 13 3.3333 3（// 整除）
print(a % b, a ** b)          # 1 1000（% 取余，** 幂）

# 比较与逻辑
print(a > b and b > 0)        # True
print(not (a == b))           # True

# 海象运算符（3.8+）：赋值同时判断
if (n := 10) > 5:
    print(n)                  # 10

# if / elif / else —— 注意：Python 用缩进表示代码块
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:
    print("良好")
else:
    print("继续努力")

# for 循环遍历
for i in range(5):        # 0 1 2 3 4
    print(i)

for ch in "abc":          # 遍历字符串
    print(ch)

# while 循环
count = 0
while count < 3:
    print(count)
    count += 1

# break 跳出 / continue 跳过本轮
for i in range(10):
    if i == 3:
        continue
    if i == 6:
        break
    print(i)

def greet(name: str, greeting: str = "Hello") -> str:
    """位置参数 + 默认参数"""
    return f"{greeting}, {name}!"

print(greet("Tom"))                     # Hello, Tom!
print(greet("Tom", greeting="你好"))     # 你好, Tom!

# 可变参数
def total(*args, **kwargs):
    print(args)      # 元组：位置参数打包
    print(kwargs)    # 字典：关键字参数打包

total(1, 2, x=3, y=4)   # (1, 2) {'x': 3, 'y': 4}

# 多返回值（其实是元组解包）
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi)   # 1 5

# 匿名函数
pairs = [(1, 'b'), (2, 'a')]
pairs.sort(key=lambda p: p[1])   # 按第二个元素排序

# list 列表 —— 有序、可变
nums = [1, 2, 3]
nums.append(4)          # 尾部追加
nums.insert(0, 0)       # 指定位置插入
nums.pop()              # 弹出尾部
print(nums[0], nums[-1])  # 首元素 / 末元素

# tuple 元组 —— 有序、不可变
point = (10, 20)
x, y = point            # 解包

# dict 字典 —— 键值对、查找 O(1)
user = {"name": "Tom", "age": 30}
user["email"] = "tom@example.com"    # 增/改
print(user.get("phone", "未设置"))    # 安全读取，避免 KeyError
for key, value in user.items():      # 遍历
    print(key, value)

# set 集合 —— 去重、交并差
a = {1, 2, 3}
b = {2, 3, 4}
print(a & b)   # 交集 {2, 3}
print(a | b)   # 并集 {1, 2, 3, 4}
print(a - b)   # 差集 {1}

lst = [0, 1, 2, 3, 4, 5]
lst[1:4]      # [1, 2, 3]     下标 [1, 4)
lst[:3]       # [0, 1, 2]     前三个
lst[-2:]      # [4, 5]        最后两个
lst[::2]      # [0, 2, 4]     步长 2
lst[::-1]     # 反转

s = "Python"
print(s[::-1])   # nohtyP —— 字符串同样适用

# 列表推导式
squares = [x ** 2 for x in range(10)]
evens = [x for x in range(20) if x % 2 == 0]

# 带条件的嵌套
matrix = [[1, 2], [3, 4]]
flat = [n for row in matrix for n in row]   # [1, 2, 3, 4]

# 字典 / 集合推导式
name_lens = {name: len(name) for name in ["Tom", "Jerry"]}
unique_lens = {len(name) for name in ["Tom", "Jerry", "Bob"]}

# 生成器表达式 —— 惰性求值，省内存
total = sum(x ** 2 for x in range(1_000_000))

# 生成器函数：yield 逐个产出，不一次性占用内存
def countdown(n):
    while n > 0:
        yield n
        n -= 1

for i in countdown(3):
    print(i)     # 3 2 1

# 处理大文件的标准姿势
# with open("huge.log", encoding="utf-8") as f:
#     for line in f:          # 逐行读取
#         process(line)

import functools
import time

# 装饰器：在不改函数代码的前提下叠加行为（计时、缓存、鉴权……）
def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} 耗时 {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timer
def work(n):
    return sum(range(n))

work(10_000_000)   # work 耗时 0.21s

# with 自动释放资源：文件、锁、数据库连接……
with open("demo.txt", "w", encoding="utf-8") as f:
    f.write("自动关闭文件，即使中途抛异常")

# 自定义上下文管理器
from contextlib import contextmanager

@contextmanager
def timer_block(name):
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"{name} 耗时 {time.perf_counter() - start:.3f}s")

with timer_block("任务"):
    sum(range(1_000_000))

try:
    value = int("abc")
except ValueError as e:
    print(f"转换失败: {e}")
except (TypeError, KeyError):
    print("其他异常")
else:
    print("没有异常时执行")
finally:
    print("无论如何都执行（清理现场）")

# 自定义异常
class ConfigError(Exception):
    pass

def load_config(path: str):
    if not path.endswith(".json"):
        raise ConfigError("配置文件必须是 .json")

from dataclasses import dataclass

class Device:
    """设备基类"""

    def __init__(self, ip: str, port: int = 502):
        self.ip = ip
        self.port = port

    def connect(self) -> str:
        return f"connect {self.ip}:{self.port}"

    def __repr__(self) -> str:       # 自定义打印
        return f"Device({self.ip})"

class Plc(Device):
    """PLC 继承设备"""

    def __init__(self, ip: str, vendor: str):
        super().__init__(ip)          # 调用父类构造
        self.vendor = vendor

    def connect(self) -> str:         # 多态：重写
        return f"[{self.vendor}] " + super().connect()

devices = [Device("192.168.3.10"), Plc("192.168.3.11", "Siemens")]
for d in devices:
    print(d.connect())
# connect 192.168.3.10:502
# [Siemens] connect 192.168.3.11:502

# dataclass：纯数据类，自动生成 __init__/__repr__/__eq__
@dataclass
class Point:
    x: float
    y: float

p = Point(1.0, 2.0)
print(p)    # Point(x=1.0, y=2.0)

# 注解不影响运行，但配合 IDE / mypy 能提前抓住大量 bug
def process(items: list[str], limit: int | None = None) -> dict[str, int]:
    result = {item: len(item) for item in items}
    return dict(list(result.items())[:limit] if limit else result.items())

# 常见写法
# int | None        —— 3.10+ 联合类型（旧版用 Optional[int]）
# list[str]         —— 3.9+ 内建泛型（旧版用 List[str]）
# Callable[[int], str]  —— 可调用对象

# import 的几种姿势
import os                      # 整个模块
import numpy as np             # 起别名
from pathlib import Path       # 只导入某个名字
from collections import defaultdict, Counter

# 工程结构示例
# my_project/
# ├── .venv/
# ├── my_app/
# │   ├── __init__.py       # 有它才是包
# │   ├── main.py
# │   └── utils/
# │       ├── __init__.py
# │       └── helpers.py
# ├── requirements.txt
# └── README.md

# if __name__ == "__main__" —— 作为脚本运行才执行，被导入时不执行
def main():
    print("程序入口")

if __name__ == "__main__":
    main()

from pathlib import Path

p = Path("data") / "logs" / "app.log"   # 跨平台路径拼接
p.parent        # data/logs
p.suffix        # .log
p.exists()      # 是否存在
p.read_text(encoding="utf-8")            # 一行读文件
p.write_text("hello", encoding="utf-8")  # 一行写文件

for f in Path(".").glob("*.py"):         # 通配查找
    print(f)

import json

data = {"name": "Tom", "tags": ["python", "rpa"]}

s = json.dumps(data, ensure_ascii=False, indent=2)   # 对象 -> 字符串
obj = json.loads(s)                                  # 字符串 -> 对象

# 读写文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

import re

text = "联系 tom@example.com 或 tom@chenpan.com.cn"

# 提取所有邮箱
emails = re.findall(r"[\w.]+@[\w.]+", text)
print(emails)

m = re.search(r"(\d{4})-(\d{2})-(\d{2})", "今天是 2026-09-23")
if m:
    print(m.group(0))   # 2026-09-23
    print(m.group(1))   # 2026

from datetime import datetime, timedelta, date

now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))    # 格式化输出

dt = datetime.strptime("2026-09-23", "%Y-%m-%d")   # 字符串解析
tomorrow = dt + timedelta(days=1)                   # 日期运算

print((now - dt).days)    # 相差天数

from collections import Counter, defaultdict, deque

# Counter 计数神器
words = ["apple", "egg", "apple", "banana", "egg", "apple"]
print(Counter(words).most_common(2))   # [('apple', 3), ('egg', 2)]

# defaultdict 带默认值的字典，分组不再 KeyError
groups = defaultdict(list)
for name, dept in [("Tom", "RPA"), ("Jerry", "FAB"), ("Bob", "RPA")]:
    groups[dept].append(name)
print(dict(groups))    # {'RPA': ['Tom', 'Bob'], 'FAB': ['Jerry']}

# deque 双端队列，适合做队列 / 滑动窗口
q = deque(maxlen=3)
for i in range(5):
    q.append(i)
print(q)    # deque([2, 3, 4], maxlen=3)

from itertools import chain, groupby, product
from functools import lru_cache, partial, reduce

print(list(chain([1, 2], [3, 4])))      # 拼接 [1, 2, 3, 4]
print(list(product("AB", repeat=2)))    # 笛卡尔积

@lru_cache(maxsize=None)                # 记忆化缓存
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)

print(fib(100))   # 瞬间出结果

print(reduce(lambda a, b: a * b, range(1, 6)))   # 120 阶乘

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s [%(name)s] %(message)s",
)
log = logging.getLogger("app")

log.info("服务启动")
log.warning("配置缺失，使用默认值")
try:
    1 / 0
except ZeroDivisionError:
    log.exception("出错了")   # 自动附带堆栈

import asyncio

async def fetch(name: str, delay: int) -> str:
    await asyncio.sleep(delay)      # 模拟 IO 等待
    return f"{name} done"

async def main():
    # 并发执行，总耗时 ≈ 最长的那个，而不是相加
    results = await asyncio.gather(
        fetch("任务A", 2),
        fetch("任务B", 1),
    )
    print(results)

asyncio.run(main())

# requests —— 调接口
import requests

resp = requests.get("https://httpbin.org/json", timeout=10)
resp.raise_for_status()          # 非 2xx 直接抛异常
print(resp.json()["slideshow"]["title"])

# pandas —— 表格处理
import pandas as pd

df = pd.DataFrame({
    "设备": ["PLC-1", "PLC-2", "PLC-3"],
    "产量": [120, 95, 130],
})
print(df.describe())          # 统计摘要
print(df.sort_values("产量", ascending=False))   # 排序
df.to_excel("output.xlsx", index=False)          # 一行导出 Excel

# FastAPI —— 三行起一个接口服务
from fastapi import FastAPI

app = FastAPI()

@app.get("/devices/{device_id}")
def get_device(device_id: str):
    return {"id": device_id, "status": "online"}

# uvicorn main:app --reload 启动，自带交互式文档 /docs

# pydantic —— 数据模型校验
from pydantic import BaseModel, EmailStr

class User(BaseModel):
    name: str
    email: EmailStr        # 自动校验邮箱格式
    age: int | None = None

user = User(name="Tom", email="tom@example.com")
print(user.model_dump())

from ultralytics import YOLO

model = YOLO("yolo26n.pt")                  # 预训练模型
results = model("defect_part.jpg", conf=0.5)

for r in results:
    for box in r.boxes:
        cls = model.names[int(box.cls)]     # 类别名
        conf = float(box.conf)              # 置信度
        x1, y1, x2, y2 = box.xyxy[0].tolist()   # 框坐标
        print(f"{cls} {conf:.2f} ({x1:.0f},{y1:.0f})-({x2:.0f},{y2:.0f})")
    r.save(filename="result.jpg")           # 保存可视化

import cv2, requests
from ultralytics import YOLO

model = YOLO("best.engine")     # TensorRT 引擎

cap = cv2.VideoCapture(0)       # GigE/USB 工业相机
while True:
    ok, frame = cap.read()
    if not ok:
        break
    r = model(frame, verbose=False)[0]
    ng = [b for b in r.boxes if b.conf > 0.6]
    if ng:
        # 1) 保存 NG 图与记录  2) 触发 PLC 剔除/声光报警
        requests.post("http://plc-gateway/api/kick", json={"count": len(ng)})
    cv2.imshow("inspector", r.plot())
    if cv2.waitKey(1) == 27:
        break