# 安装 DrissionPage
pip install DrissionPage

# 安装备选方案（可选）
pip install playwright
pip install selenium

from DrissionPage import ChromiumPage

# 创建页面对象
page = ChromiumPage()

# 访问淘宝
page.get('https://www.taobao.com')

# 搜索商品
search_box = page.ele('#q')
search_box.input('手机')
search_box.after().click()

# 获取商品信息
products = page.eles('.item')
for product in products:
    title = product.ele('.title').text
    price = product.ele('.price').text
    print(f"{title}: {price}")

from DrissionPage import ChromiumPage
from crawler.gateway.proxy_server import ProxyServer

class TaobaoAutomator:
    def __init__(self):
        # 启动代理服务器
        self.proxy_server = ProxyServer()

        # 配置 DrissionPage 使用代理
        self.page = ChromiumPage()
        self.page.set.proxy(f'127.0.0.1:{self.proxy_server.port}')

    def search_products(self, keyword):
        # 实现搜索逻辑
        pass

def search_by_image(self, image_path: str):
    """图片搜索功能"""
    # 1. 打开淘宝首页
    self.browser.get('https://www.taobao.com')

    # 2. 点击搜同款按钮
    search_button = self.browser.ele('css:.image-search-icon-wrapper')
    search_button.click()

    # 3. 上传图片
    file_input = self.browser.ele('css:#image-search-custom-file-input')
    file_input.input(image_path)

    # 4. 等待上传完成并搜索
    self._wait_for_upload_complete()
    search_btn = self.browser.ele('css:#image-search-upload-button')
    search_btn.click()

    # 5. 提取商品数据
    return self._extract_products_from_page()

def response(flow: http.HTTPFlow) -> None:
    """拦截API响应"""
    if 'h5api.m.taobao.com' in flow.request.pretty_url:
        content = flow.response.text
        # 解析JSONP响应，提取商品数据
        data = parse_jsonp_response(content)
        save_to_file(data)

def generate_excel_report(self, products_data):
    """生成Excel报告"""
    workbook = openpyxl.Workbook()

    for sheet_data in products_data:
        worksheet = workbook.create_sheet(sheet_data['name'])

        # 添加商品数据
        self.add_product_data(worksheet, sheet_data['products'])

        # 下载并添加商品图片
        self.add_product_images(worksheet, sheet_data['products'])

    workbook.save('report.xlsx')

def compress_image(self, image_path: str) -> str:
    """智能图片压缩"""
    with Image.open(image_path) as img:
        # 调整尺寸到400x400
        if img.width > 400 or img.height > 400:
            img.thumbnail((400, 400), Image.Resampling.LANCZOS)

        # 压缩质量到40%
        img.save(compressed_path, "JPEG", quality=40, optimize=True)

    return compressed_path

# 随机延迟模拟人类行为
import random
time.sleep(random.uniform(1, 3))

# 滚动页面
self.browser.scroll_to_bottom()

# 直接设置文件路径
file_input = self.browser.ele('css:#image-search-custom-file-input')
self.browser.run_js(f"arguments[0].value = '{image_path}'", file_input)

def find_items_recursively(self, obj):
    """递归查找商品数据"""
    if isinstance(obj, dict) and self._is_product_item(obj):
        return [self._extract_product_info(obj)]

    if isinstance(obj, list):
        for item in obj:
            result = self.find_items_recursively(item)
            if result:
                return result

    return []

taobao-search/
├── run.py                    # 主启动脚本
├── src/                      # 源代码
│   ├── automation/           # 自动化模块
│   ├── email/               # 邮件服务
│   ├── excel/               # Excel处理
│   └── workflow/            # 工作流程
├── config/                  # 配置文件
├── IMG_LIST/                # 图片目录
└── data/                    # 数据目录

import pymysql

conn = pymysql.connect(host='localhost', user='user', password='password', database='testdb')
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(100), email VARCHAR(100) UNIQUE)")
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Alice', 'alice@example.com'))
conn.commit()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()

import psycopg2

conn = psycopg2.connect(host='localhost', user='user', password='password', dbname='testdb')
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name TEXT, email TEXT UNIQUE)")
cursor.execute("INSERT INTO users (name, email) VALUES (%s, %s)", ('Bob', 'bob@example.com'))
conn.commit()
cursor.execute("SELECT * FROM users")
print(cursor.fetchall())
cursor.close()
conn.close()

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(100))
    email = Column(String(100), unique=True)

DATABASE_URL = 'postgresql+psycopg2://user:password@localhost:5432/testdb'

engine = create_engine(DATABASE_URL)
Session = sessionmaker(bind=engine)
session = Session()

Base.metadata.create_all(engine)

new_user = User(name='Carol', email='carol@example.com')
session.add(new_user)
session.commit()

users = session.query(User).all()
for u in users:
    print(u.id, u.name, u.email)

session.close()

sysbench oltp_read_write \
  --db-driver=mysql \
  --mysql-host=DB_HOST \
  --mysql-user=testuser \
  --mysql-password=secret \
  --mysql-db=testdb \
  --tables=10 \
  --table-size=1000000 \
  prepare

sysbench oltp_read_write --threads=100 --time=300 run

sysbench oltp_read_write cleanup

pgbench -h DB_HOST -U testuser -d testdb -i -s 1000

pgbench -h DB_HOST -U testuser -d testdb -c 100 -T 300 -j 4

import asyncio
import aiomysql

DB_CONFIG = dict(host='DB_HOST', user='testuser', password='secret', db='testdb', minsize=10, maxsize=100)

async def task(pool):
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            await cur.execute("SELECT COUNT(*) FROM orders WHERE status='pending'")
            await cur.fetchone()
            await cur.execute("UPDATE users SET last_login=NOW() WHERE id=%s", (1,))

async def run_load(concurrency, duration):
    pool = await aiomysql.create_pool(**DB_CONFIG)
    end_time = asyncio.get_event_loop().time() + duration
    sem = asyncio.Semaphore(concurrency)

    async def worker():
        async with sem:
            while asyncio.get_event_loop().time() < end_time:
                await task(pool)

    await asyncio.gather(*[worker() for _ in range(concurrency)])
    pool.close()
    await pool.wait_closed()

asyncio.run(run_load(concurrency=50, duration=300))

#!/bin/bash
DB_TYPE=${1:-mysql}
DB_HOST="127.0.0.1"
DB_PORT_MYSQL=3306
DB_PORT_PG=5432
DB_USER="testuser"
DB_PASS="secret"
DB_NAME="testdb"
CONCURRENCY=(10 50 100)
DURATION=120
SCALE=100

function bench_mysql() {
    sysbench oltp_read_write \
        --threads=$1 \
        --time=$DURATION \
        --db-driver=mysql \
        --mysql-host=$DB_HOST \
        --mysql-port=$DB_PORT_MYSQL \
        --mysql-user=$DB_USER \
        --mysql-password=$DB_PASS \
        --mysql-db=$DB_NAME run | tee mysql_${1}c.log
}

function bench_pgsql() {
    pgbench -h $DB_HOST -p $DB_PORT_PG -U $DB_USER -d $DB_NAME -c $1 -T $DURATION -j $(nproc) | tee pg_${1}c.log
}

if [[ $DB_TYPE == "pgsql" ]]; then
    pgbench -h $DB_HOST -p $DB_PORT_PG -U $DB_USER -d $DB_NAME -i -s $SCALE
fi

for c in "${CONCURRENCY[@]}"; do
    if [[ $DB_TYPE == "mysql" ]]; then
        bench_mysql $c
    else
        bench_pgsql $c
    fi
done

echo "压测完成，查看 *_c.log 文件"

# 传统写法
squares = []
for x in range(10):
    squares.append(x**2)

# 列表推导式
squares = [x**2 for x in range(10)]

# 搭配条件过滤
even_squares = [x**2 for x in range(10) if x % 2 == 0]

# 可能抛出 KeyError
user_name = user_dict['name']

# 更稳健的写法
user_name = user_dict.get('name', 'Unknown')

fruits = ['apple', 'banana', 'orange']

for index, fruit in enumerate(fruits, start=1):
    print(f"{index}. {fruit}")

names = ['Alice', 'Bob', 'Charlie']
ages = [25, 30, 35]

for name, age in zip(names, ages):
    print(f"{name} 的年龄是 {age} 岁")

name = "World"
age = 25

message = f"Hello, {name}! You are {age} years old."