# 价格带分析示例def price_band_analysis(category, platform_prices):
    """
    分析某品类在各平台的价格分布
    platform_prices: {平台: [价格列表]}
    """
    results = {}
    for platform, prices in platform_prices.items():
        results[platform] = {
            "min": min(prices),
            "max": max(prices),
            "median": np.median(prices),
            "q1": np.percentile(prices, 25),   # 下四分位
            "q3": np.percentile(prices, 75),   # 上四分位
            "mean": np.mean(prices)
        }
    return results# 示例输出# 数码3C品类：# 淘宝: {min: 280, max: 380, median: 320, q1: 300, q3: 340}# 京东: {min: 300, max: 400, median: 340, q1: 320, q3: 360}# 拼多多: {min: 240, max: 340, median: 280, q1: 260, q3: 300}# 1688: {min: 180, max: 280, median: 220, q1: 200, q3: 240}

┌─────────────────────────────────────────────────────────────┐
│                    多平台比价系统架构                          │
├─────────────────────────────────────────────────────────────┤
│  数据采集层                                                  │
│  ├─ 淘宝 API / 爬虫  → 商品标题、价格、销量、评价、SKU        │
│  ├─ 京东 API / 爬虫  → 自营价、第三方价、促销信息、库存        │
│  ├─ 拼多多 API       → 团购价、单买价、百亿补贴价             │
│  └─ 1688 API         → 批发价、起订量、混批规则、运费          │
├─────────────────────────────────────────────────────────────┤
│  数据清洗层                                                  │
│  ├─ 去重：同一商品多链接合并                                  │
│  ├─ 标准化：统一货币单位、规格单位、时间格式                   │
│  ├─ 异常值处理：剔除 0 元、99999 元等异常价格                 │
│  └─ 到手价计算：叠加满减、优惠券、红包后的真实支付价格          │
├─────────────────────────────────────────────────────────────┤
│  存储层                                                      │
│  ├─ 时序数据库（InfluxDB）：价格历史数据                       │
│  ├─ 关系数据库（PostgreSQL）：商品基础信息、SKU 关系          │
│  └─ 缓存（Redis）：热点商品价格实时缓存                        │
├─────────────────────────────────────────────────────────────┤
│  分析引擎层                                                  │
│  ├─ 价格趋势预测：ARIMA / LSTM 时序模型                      │
│  ├─ 竞品关联：标题相似度 + 图片哈希匹配同款                    │
│  ├─ 定价建议：基于成本 + 竞品价格 + 弹性系数的动态定价         │
│  └─ 异常检测：突然降价/涨价识别，触发告警                     │
├─────────────────────────────────────────────────────────────┤
│  应用层                                                      │
│  ├─ 可视化看板：价格走势、溢价率热力图、波动率对比             │
│  ├─ 告警推送：微信/钉钉/邮件，价格突破阈值实时通知            │
│  └─ 报表导出：Excel / PDF，支持按品类、店铺、时间维度筛选       │
└─────────────────────────────────────────────────────────────┘

import requestsimport pandas as pdfrom datetime import datetimeimport hashlibimport hmacclass MultiPlatformPriceComparator:
    """多平台商品比价引擎"""
    
    def __init__(self, api_keys):
        self.api_keys = api_keys
        self.platform_apis = {
            "taobao": "https://api.taobao.com/router/rest",
            "jd": "https://api.jd.com/routerjson",
            "pdd": "https://api.pinduoduo.com/api/router",
            "1688": "https://api.1688.com/openapi/"
        }
    
    def fetch_price(self, platform, keyword_or_sku):
        """获取单平台商品价格"""
        if platform == "taobao":
            return self._fetch_taobao(keyword_or_sku)
        elif platform == "jd":
            return self._fetch_jd(keyword_or_sku)
        elif platform == "pdd":
            return self._fetch_pdd(keyword_or_sku)
        elif platform == "1688":
            return self._fetch_1688(keyword_or_sku)
    
    def _fetch_taobao(self, keyword):
        """淘宝价格采集"""
        params = {
            "method": "taobao.item.search",
            "app_key": self.api_keys["taobao"]["app_key"],
            "q": keyword,
            "fields": "num_iid,title,price,sold_quantity,nick,pic_url",
            "page_size": 20
        }
        # 签名逻辑...
        resp = requests.get(self.platform_apis["taobao"], params=params, timeout=10)
        items = resp.json().get("items", [])
        return [{
            "platform": "淘宝",
            "title": item["title"],
            "price": float(item["price"]),
            "sales": int(item.get("sold_quantity", 0)),
            "shop": item["nick"],
            "url": f"https://item.taobao.com/item.htm?id={item['num_iid']}"
        } for item in items]
    
    def _calculate_real_price(self, item):
        """计算到手价（含促销）"""
        base_price = item["price"]
        # 叠加满减
        if item.get("discount"):
            base_price *= (1 - item["discount"])
        # 叠加优惠券
        if item.get("coupon"):
            base_price -= item["coupon"]
        # 叠加平台补贴
        if item.get("subsidy"):
            base_price -= item["subsidy"]
        return round(max(base_price, 0.01), 2)
    
    def compare_same_product(self, product_identifiers):
        """
        跨平台同款比价
        product_identifiers: {
            "taobao": "sku_id_1",
            "jd": "sku_id_2", 
            "pdd": "sku_id_3",
            "1688": "sku_id_4"
        }
        """
        results = []
        for platform, sku_id in product_identifiers.items():
            data = self.fetch_price(platform, sku_id)
            if data:
                item = data[0]
                item["real_price"] = self._calculate_real_price(item)
                results.append(item)
        
        # 计算价差
        if results:
            prices = [r["real_price"] for r in results]
            min_price = min(prices)
            for r in results:
                r["premium"] = round((r["real_price"] - min_price) / min_price * 100, 2)
        
        return pd.DataFrame(results)
    
    def generate_price_report(self, comparison_df):
        """生成比价分析报告"""
        report = {
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "product_count": len(comparison_df),
            "price_stats": {
                "highest": comparison_df["real_price"].max(),
                "lowest": comparison_df["real_price"].min(),
                "mean": comparison_df["real_price"].mean(),
                "median": comparison_df["real_price"].median(),
                "std": comparison_df["real_price"].std()
            },
            "premium_analysis": comparison_df.groupby("platform")["premium"].mean().to_dict(),
            "recommendations": []
        }
        
        # 定价建议
        lowest_platform = comparison_df.loc[comparison_df["real_price"].idxmin(), "platform"]
        report["recommendations"].append(
            f"进货渠道建议：{lowest_platform} 价格最低，可作为主要采购来源"
        )
        
        # 如果某平台溢价率 > 30%，建议关注是否为品牌溢价或异常定价
        high_premium = comparison_df[comparison_df["premium"] > 30]
        if not high_premium.empty:
            report["recommendations"].append(
                f"高溢价平台：{', '.join(high_premium['platform'].tolist())}，建议核查是否为正品或存在品牌溢价"
            )
        
        return report

def brand_price_control(brand_name, min_price_map):
    """
    品牌控价监控
    min_price_map: {sku_id: 最低零售价}
    """
    violations = []
    for sku_id, min_price in min_price_map.items():
        # 采集全网该 SKU 价格
        prices = fetch_all_platform_prices(sku_id)
        for p in prices:
            if p["real_price"] < min_price:
                violations.append({
                    "sku_id": sku_id,
                    "platform": p["platform"],
                    "shop": p["shop"],
                    "current_price": p["real_price"],
                    "min_price": min_price,
                    "violation_rate": round((min_price - p["real_price"]) / min_price * 100, 2),
                    "screenshot": capture_screenshot(p["url"]),
                    "timestamp": datetime.now()
                })
    return violations

def pricing_recommendation(cost_price, category, target_platform):
    """
    基于竞品数据的定价建议
    """
    # 获取同品类竞品数据
    competitors = fetch_category_prices(category, target_platform)
    
    # 计算价格分位
    p25 = np.percentile(competitors, 25)
    p50 = np.percentile(competitors, 50)
    p75 = np.percentile(competitors, 75)
    
    # 定价策略
    if cost_price < p25:
        # 成本优势大，可低价抢占市场
        recommended = p25 * 0.95
        strategy = "渗透定价"
    elif cost_price < p50:
        # 成本中等，跟随市场
        recommended = p50
        strategy = "竞争定价"
    else:
        # 成本高，需差异化
        recommended = p75 * 1.05
        strategy = "撇脂定价"
    
    margin = (recommended - cost_price) / recommended * 100
    
    return {
        "recommended_price": round(recommended, 2),
        "strategy": strategy,
        "expected_margin": round(margin, 2),
        "competitor_range": f"{p25} - {p75}",
        "confidence": "高" if len(competitors) > 50 else "中"
    }

def cross_border_sourcing_analysis(product_keyword):
    """
    跨境代采利润分析
    """
    # 获取 1688 批发价
    _1688_items = fetch_1688_prices(product_keyword)
    
    # 获取目标市场零售价（如 Shopee 东南亚）
    shopee_items = fetch_shopee_prices(product_keyword)
    
    analysis = []
    for item_1688 in _1688_items:
        cost = item_1688["price"]  # 1688 批发价
        moq = item_1688["min_order"]  # 起订量
        
        # 找同款在 Shopee 的售价
        matching_shopee = find_matching_item(item_1688, shopee_items)
        if matching_shopee:
            selling_price = matching_shopee["price"]
            
            # 计算利润
            logistics_cost = selling_price * 0.15  # 物流约 15%
            platform_fee = selling_price * 0.05   # 平台佣金约 5%
            profit = selling_price - cost - logistics_cost - platform_fee
            margin = profit / selling_price * 100
            
            analysis.append({
                "product": item_1688["title"],
                "1688_price": cost,
                "shopee_price": selling_price,
                "moq": moq,
                "logistics": round(logistics_cost, 2),
                "platform_fee": round(platform_fee, 2),
                "profit": round(profit, 2),
                "margin": round(margin, 2),
                "recommendation": "推荐" if margin > 30 else "谨慎"
            })
    
    return sorted(analysis, key=lambda x: x["margin"], reverse=True)