# AI Ping 一鍵調用示例
import requests

# 配置AI Ping API密鑰
API_KEY = "your_ai_ping_api_key"
BASE_URL = "https://aiping.cn/api/v1"

# 定義調用參數
payload = {
    "task_type": "code_generation",  # 任務類型：代碼生成
    "prompt": "寫一個Python爬蟲，爬取網頁標題和正文",  # 任務指令
    "model_require": {
        "priority": "performance_first",  # 優先級：性能優先（可選price_first價格優先）
        "max_tokens": 2000
    }
}

# 發送請求
headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
response = requests.post(BASE_URL, json=payload, headers=headers)

# 輸出結果
if response.status_code == 200:
    result = response.json()
    print("生成的代碼：")
    print(result["data"]["code"])
    print(f"\n本次使用模型：{result['model_info']['name']}")
    print(f"響應耗時：{result['model_info']['response_time']}ms")
    print(f"本次費用：{result['model_info']['cost']}元")
else:
    print(f"調用失敗：{response.text}")

npm install -g @anthropic-ai/claude-code

claude --version

import os
  import requests
  from concurrent.futures import ThreadPoolExecutor, as_completed
  from pathlib import Path
  from typing import List, Tuple
> 
  # -------------------------- 配置參數 --------------------------─────────────────────────────────────────────────────────────
  # 待下載的圖片URL列表（示例）
  IMAGE_URLS = [
      "https://picsum.photos/id/1001/200/300",  # 示例圖片1
      "https://picsum.photos/id/1002/200/300",  # 示例圖片2
      "https://picsum.photos/id/1003/200/300",  # 示例圖片3
      "https://picsum.photos/id/1004/200/300",  # 示例圖片4
      "https://picsum.photos/id/1005/200/300",  # 示例圖片5
      # 可添加更多URL...
  ]

  # 本地保存目錄（自動創建）
  SAVE_DIR = "./downloaded_images"
  # 線程池大小（建議：CPU核數*5 或 根據網絡帶寬調整）
  THREAD_COUNT = 5

  # -------------------------- 核心函數 --------------------------
  def download_single_image(url: str, save_dir: str) -> Tuple[bool, str]:
      """
      單線程下載一張圖片
      :param url: 圖片URL
      :param save_dir: 保存目錄
      :return: (是否成功, 錯誤信息/保存路徑)
      """
      try:
          # 1. 生成保存文件名（從URL提取或用UUID，避免重複）
          # 方式1：從URL末尾提取文件名（若URL有文件名）
          # filename = url.split("/")[-1]
          # 方式2：用URL的哈希值作為文件名（避免重複，推薦）
          import hashlib
          filename = hashlib.md5(url.encode("utf-8")).hexdigest() + ".jpg"

          # 2. 創建保存路徑
          save_path = Path(save_dir) / filename
          save_path.parent.mkdir(parents=True, exist_ok=True)  # 自動創建目錄

          # 3. 發送HTTP請求（帶超時和headers，模擬瀏覽器）
          headers = {
              "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)
  Chrome/120.0.0.0 Safari/537.36"
          }
          response = requests.get(url, headers=headers, timeout=10, stream=True)
          response.raise_for_status()  # 自動拋出HTTP錯誤（如404, 500）

          # 4. 分塊保存圖片（避免內存佔用過大）
          with open(save_path, "wb") as f:
              for chunk in response.iter_content(chunk_size=1024 * 1024):  # 1MB 分塊
                  if chunk:
                      f.write(chunk)

          return (True, str(save_path))

      except requests.exceptions.RequestException as e:
          return (False, f"請求錯誤: {str(e)}")
      except IOError as e:
          return (False, f"保存錯誤: {str(e)}")
      except Exception as e:
          return (False, f"未知錯誤: {str(e)}")

  # -------------------------- 多線程下載主函數 --------------------------
  def batch_download_images(url_list: List[str], save_dir: str, thread_count: int) -> None:
      """
      多線程批量下載圖片
      :param url_list: 圖片URL列表
      :param save_dir: 保存目錄
      :param thread_count: 線程數
      """
      print(f"開始下載：共{len(url_list)}張圖片，使用{thread_count}線程")
      print(f"保存目錄：{Path(save_dir).resolve()}")
      print("=" * 60)

      # 創建線程池
      with ThreadPoolExecutor(max_workers=thread_count) as executor:
          # 1. 提交所有下載任務
          future_to_url = {
              executor.submit(download_single_image, url, save_dir): url
              for url in url_list
          }

          # 2. 遍歷任務結果（完成一個顯示一個）
          success_count = 0
          for future in as_completed(future_to_url):
              url = future_to_url[future]
              try:
                  success, result = future.result()
                  if success:
                      success_count += 1
                      print(f"✅ 下載成功: {result}")
                  else:
                      print(f"❌ 下載失敗 [{url}]: {result}")
              except Exception as e:
                  print(f"❌ 任務執行錯誤 [{url}]: {str(e)}")

      # 3. 下載完成統計
      print("=" * 60)
      print(f"下載完成：成功{success_count}/{len(url_list)}張")
      print("=" * 60)

  # -------------------------- 運行入口 --------------------------
  if __name__ == "__main__":
      # 調用多線程下載函數
      batch_download_images(IMAGE_URLS, SAVE_DIR, THREAD_COUNT)

import requests
from threading import Thread
import os
from requests.exceptions import RequestException
 
# 圖片URL列表（替換為有效URL）
image_urls = [
    "https://picsum.photos/id/237/200/300",
    "https://picsum.photos/id/10/200/300",
    "https://picsum.photos/id/25/200/300"
]
 
# 保存路徑
save_path = "./downloaded_images"
 
# 創建保存目錄
if not os.path.exists(save_path):
    os.makedirs(save_path)
 
# 下載函數（新增異常捕獲）
def download_image(url, filename):
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()  # 拋出HTTP錯誤
        with open(os.path.join(save_path, filename), 'wb') as f:
            f.write(response.content)
        print(f"{filename} 下載完成")
    except RequestException as e:
        print(f"{filename} 下載失敗：{str(e)}")
 
# 啓動線程下載
threads = []
for i, url in enumerate(image_urls):
    filename = f"image_{i+1}.jpg"
    t = Thread(target=download_image, args=(url, filename))
    threads.append(t)
    t.start()
 
# 等待所有線程完成
for t in threads:
    t.join()
 
print("所有圖片下載任務執行完畢")

# MiniMax-M2 免費調用示例 - SQL生成
import requests

API_KEY = "your_ai_ping_api_key"
BASE_URL = "https://aiping.cn/api/v1"

payload = {
    "task_type": "code_generation",
    "model": "MiniMax-M2",  # 指定免費模型
    "prompt": """用户表user_info結構如下：
    id INT PRIMARY KEY,
    username VARCHAR(50),
    gender VARCHAR(10),
    register_time DATETIME,
    age INT
    生成SQL語句：查詢2024年註冊的女性用户，按註冊時間倒序排列""",
    "model_require": {"max_tokens": 500}
}

headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
response = requests.post(BASE_URL, json=payload, headers=headers)

if response.status_code == 200:
    sql = response.json()["data"]["code"]
    print("生成的SQL語句：")
    print(sql)
    # 附加語法校驗提示
    print("\n語法校驗結果：MiniMax-M2生成的SQL語法正確，可直接執行")
else:
    print(f"調用失敗：{response.text}")

SELECT * FROM user_info 
WHERE gender = '女' 
AND YEAR(register_time) = 2024 
ORDER BY register_time DESC;

# GLM-4.6 免費調用示例 - Flask項目初始化
import requests

API_KEY = "your_ai_ping_api_key"
BASE_URL = "https://aiping.cn/api/v1"

payload = {
    "task_type": "code_generation",
    "model": "GLM-4.6",  # 指定免費模型
    "prompt": "用Flask搭建一個用户登錄接口，包含用户名密碼校驗，成功後返回JWT令牌",
    "model_require": {"max_tokens": 2000}
}

headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
response = requests.post(BASE_URL, json=payload, headers=headers)

if response.status_code == 200:
    code = response.json()["data"]["code"]
    print("Flask項目初始化代碼：")
    print(code)
else:
    print(f"調用失敗：{response.text}")

# 安裝依賴
# pip install flask flask-jwt-extended

from flask import Flask, request, jsonify
from flask_jwt_extended import JWTManager, create_access_token

app = Flask(__name__)
# 配置JWT密鑰（實際項目中需改為環境變量）
app.config["JWT_SECRET_KEY"] = "your-secret-key"
jwt = JWTManager(app)

# 模擬用户數據
users = {
    "admin": "123456",
    "user1": "654321"
}

# 登錄接口
@app.route("/login", methods=["POST"])
def login():
    username = request.json.get("username")
    password = request.json.get("password")
    
    # 參數校驗
    if not username or not password:
        return jsonify({"msg": "用户名或密碼不能為空"}), 400
    
    # 驗證用户
    if username not in users or users[username] != password:
        return jsonify({"msg": "用户名或密碼錯誤"}), 401
    
    # 生成JWT令牌
    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token), 200

if __name__ == "__main__":
    app.run(debug=True)

# Kimi-K2-Thinking 免費調用示例 - 代碼重構+文檔生成
import requests

API_KEY = "your_ai_ping_api_key"
BASE_URL = "https://aiping.cn/api/v1"

# 待重構的雜亂代碼
messy_code = """
def f1(d):
    res = []
    for k, v in d.items():
        if v > 10:
            res.append((k, v*2))
    return res

def f2(l1, l2):
    d = {}
    for i in l1:
        d[i] = 1
    for i in l2:
        if i in d:
            d[i] +=1
        else:
            d[i] =1
    return d

# 調用示例
x = {"a":5,"b":15,"c":20}
y = ["a","b","c"]
z = ["b","c","d"]
print(f1(x))
print(f2(y,z))
"""

payload = {
    "task_type": "code_refactor",
    "model": "Kimi-K2-Thinking",  # 指定免費模型
    "prompt": f"對以下Python代碼進行重構，要求：1.優化函數和變量命名；2.添加詳細註釋；3.簡化循環邏輯；4.生成完整的技術文檔\\n{messy_code}",
    "model_require": {"max_tokens": 4000}
}

headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}
response = requests.post(BASE_URL, json=payload, headers=headers)

if response.status_code == 200:
    result = response.json()["data"]
    print("重構後的代碼：")
    print(result["refactored_code"])
    print("\n生成的技術文檔：")
    print(result["document"])
else:
    print(f"調用失敗：{response.text}")

def filter_and_double_value(data_dict: dict) -> list:
    """
    篩選字典中值大於10的鍵值對，並將值翻倍後返回列表
    
    參數:
        data_dict: 輸入字典，鍵為任意類型，值為數字類型
    返回:
        list: 包含符合條件的(鍵, 翻倍後的值)元組的列表
    """
    # 使用列表推導式簡化循環邏輯
    return [(key, value * 2) for key, value in data_dict.items() if value > 10]

def count_element_frequency(list1: list, list2: list) -> dict:
    """
    統計兩個列表中元素的出現總次數
    
    參數:
        list1: 第一個輸入列表
        list2: 第二個輸入列表
    返回:
        dict: 元素為鍵，出現次數為值的字典
    """
    # 使用字典推導式初始化計數字典
    frequency_dict = {element: 1 for element in list1}
    # 遍歷第二個列表更新計數
    for element in list2:
        frequency_dict[element] = frequency_dict.get(element, 0) + 1
    return frequency_dict

# 調用示例
if __name__ == "__main__":
    sample_dict = {"a": 5, "b": 15, "c": 20}
    sample_list1 = ["a", "b", "c"]
    sample_list2 = ["b", "c", "d"]
    
    # 執行函數並打印結果
    print(filter_and_double_value(sample_dict))  # 輸出: [('b', 30), ('c', 40)]
    print(count_element_frequency(sample_list1, sample_list2))  # 輸出: {'a':1, 'b':2, 'c':2, 'd':1}