# 导入Flask模块
from flask import Flask

# 创建Flask应用实例
app = Flask(__name__)

# 定义路由和视图函数
@app.route('/')
def hello_world():
    return 'Hello, World!'

# 运行应用
if __name__ == '__main__':
    app.run(debug=True)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 定义请求模型
class TranslationRequest(BaseModel):
    client: str
    mysticTime: str
    product: str
    word: str
    from_lang: str
    to_lang: str
    useTerm: str
    cookies: str = '0'

# 将 sign 函数作为 FastAPI 的依赖项
def sign(client: str, mysticTime: str, product: str):
    str_md5 = f'{client}&{mysticTime}&{product}&key=fsdsogkndfokasodnaso'
    return hashlib.md5(str_md5.encode("utf-8")).hexdigest()

# 将 result 函数作为 FastAPI 的路径操作
@app.post("/translate/")
async def translate(request: TranslationRequest):
    ti = request.mysticTime
    data = {
        "i": request.word,
        "from": request.from_lang,
        "to": request.to_lang,
        "useTerm": request.useTerm,
        # 其他参数...
    }
    data["sign"] = sign(request.client, ti, request.product)
    data["client"] = request.client
    data["product"] = request.product
    # 其他参数赋值...

    headers = {
        # 根据需要设置 headers...
        'cookie': request.cookies
    }

    url = "https://dict.youdao.com/webtranslate" 
    response = requests.post(url, headers=headers, data=data)
    
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 保持原有 result 函数不变
# ...

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

from fastapi import FastAPI, Form, HTTPException, Response
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 定义请求模型
class TranslationRequest(BaseModel):
    word: str
    from_lang: str = 'auto'
    to_lang: str = 'auto'
    useTerm: str = 'false'
    cookies: str = ''

# 定义语言代码字典
dic_code = {
    'auto': '自动识别',
    'ar': '阿拉伯文', 'is': '冰岛文', 'pl': '波兰文', 'de': '德文',
    'ru': '俄文', 'fr': '法文', 'fi': '芬兰文', 'fy': '弗里西文',
    'tl': '菲律宾文', 'ko': '韩文', 'nl': '荷兰文', 'mn': '蒙古文',
    'my': '缅甸文', 'ne': '尼泊尔文', 'no': '挪威文', 'pt': '葡萄牙文',
    'ja': '日文', 'sv': '瑞典文', 'eo': '世界文', 'tr': '土耳其文',
    'uk': '乌克兰文', 'es': '西班牙文', 'el': '希腊文', 'haw': '夏威夷文',
    'en': '英文', 'it': '意大利文', 'zh-CHS': '中文'
}

# sign值加密
def sign(client: str, mysticTime: str, product: str):
    str_md5 = f'client={client}&mysticTime={mysticTime}&product={product}&key=fsdsogkndfokasodnaso'
    return hashlib.md5(str_md5.encode("utf-8")).hexdigest()

# 返回值解密
def result(text_AES):
    decodeiv = "ydsecret://query/iv/C@lZe2YzHtZ2CYgaXKSVfsb7Y4QWHjITPPZ0nQp87fBeJ!Iv6v^6fvi2WN@bYpJ4"
    decodekey = "ydsecret://query/key/B*RGygVywfNBwpmBaZg*WT7SIOUP2T0C9WHMZN39j^DAdaZhAnxvGcCY6VYFwnHl"
    key = hashlib.md5(decodekey.encode('utf-8')).digest()
    iv = hashlib.md5(decodeiv.encode('utf-8')).digest()
    aes_en = AES.new(key, AES.MODE_CBC, iv)
    data_new = base64.urlsafe_b64decode(text_AES)
    result = aes_en.decrypt(data_new).decode('utf-8')
    return result

# 翻译请求处理
@app.post("/translate/")
async def translate(request: TranslationRequest):
    ti = str(int(time.time() * 1000))
    client = 'fanyideskweb'
    product = 'webfanyi'
    useTerm = request.useTerm
    cookies = request.cookies if request.cookies else '[email protected]; OUTFOX_SEARCH_USER_ID_NCOO=1994625046.2245197'
    
    headers = {
        "Origin": "https://fanyi.youdao.com",
        "Referer": "https://fanyi.youdao.com",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
        'Host': 'dict.youdao.com',
        'cookie': cookies
    }

    data = {
        "i": request.word,
        "from": request.from_lang,
        "to": request.to_lang,
        "useTerm": useTerm,
        "keyid": "webfanyi",
        "sign": sign(client, ti, product),
        "client": client,
        "product": product,
        "mysticTime": ti,
        # 其他参数...
    }

    url = "https://dict.youdao.com/webtranslate"
    response = requests.post(url, headers=headers, data=data)
    
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 运行 Uvicorn 服务器
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")

uvicorn app:app --reload

from fastapi import FastAPI, Form, HTTPException
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 定义请求参数模型
class TranslationParams(BaseModel):
    word: str
    from_lang: int
    to_lang: int
    useTerm: str
    cookies: str

# 原有的 sign 函数
def sign():
    str_md5 = f'client=fanyideskweb&mysticTime={str(int(time.time() * 1000))}&product=webfanyi&key=fsdsogkndfokasodnaso'
    return hashlib.md5(str_md5.encode("utf-8")).hexdigest()

# 原有的 result 函数
def result(text_AES):
    # 省略了部分代码以保持简洁，但请确保包含完整的解密逻辑
    # ...
    pass

# 原有的语言字典
dic_code = {
    # 省略了部分字典以保持简洁，但请确保包含完整的语言代码映射
    # ...
}

# 将原有的 input 函数替换为 FastAPI 的路径操作
@app.post("/translate/")
async def translate(word: str = Form(...), from_lang: int = Form(...), to_lang: int = Form(...),
                    useTerm: str = Form(...), cookies: str = Form(...)):
    # 使用路径参数模型替代原有的 input 函数
    params = TranslationParams(word=word, from_lang=from_lang, to_lang=to_lang,
                               useTerm=useTerm, cookies=cookies)
    
    # 构建请求数据
    data = {
        "i": params.word,
        "from": 'code' + str(params.from_lang),  # 假设前端传入的是语言代码的数字索引
        "to": 'code' + str(params.to_lang),
        "useTerm": params.useTerm,
        "keyid": "webfanyi",
        "sign": sign(),
        "client": "fanyideskweb",
        "product": "webfanyi",
        "mysticTime": str(int(time.time() * 1000)),
        # 其他参数...
    }

    headers = {
        # 省略了部分 headers 以保持简洁，但请确保包含完整的请求头
        # ...
    }

    url = "https://dict.youdao.com/webtranslate"
    response = requests.post(url, headers=headers, data=data)
    
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 运行 Uvicorn 服务器
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

uvicorn your_script_name:app --reload

from fastapi import FastAPI, Form, HTTPException, Response
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 定义请求参数模型
class TranslationParams(BaseModel):
    word: str
    from_lang: str
    to_lang: str
    useTerm: str
    cookies: str = '0'

# 原有的 sign 函数
def sign():
    ti = str(int(time.time() * 1000))
    str_md5 = f'client=fanyideskweb&mysticTime={ti}&product=webfanyi&key=fsdsogkndfokasodnaso'
    return hashlib.md5(str_md5.encode("utf-8")).hexdigest()

# 原有的 result 函数
def result(text_AES):
    # 省略了部分代码以保持简洁，但请确保包含完整的解密逻辑
    # ...
    pass

# 将原有的 input 函数替换为 FastAPI 的路径操作
@app.post("/")
async def translate(word: str = Form(...), from_lang: str = Form(None), 
                    to_lang: str = Form(None), useTerm: str = Form(...), 
                    cookies: str = Form(...)):
    params = TranslationParams(word=word, from_lang=from_lang, to_lang=to_lang,
                               useTerm=useTerm, cookies=cookies)

    # 构建请求数据
    data = {
        "i": params.word,
        "from": params.from_lang if params.from_lang else 'auto',
        "to": params.to_lang if params.to_lang else 'auto',
        "useTerm": params.useTerm,
        "dictResult": "true",
        "keyid": "webfanyi",
        "sign": sign(),
        "client": "fanyideskweb",
        "product": "webfanyi",
        "appVersion": "1.0.0",
        "vendor": "web",
        "pointParam": "client,mysticTime,product",
        "mysticTime": str(int(time.time() * 1000)),
        "keyfrom": "fanyi.web",
        "mid": "1",
        "screen": "1",
        "model": "1",
        "network": "wifi",
        "abtest": "0",
        "yduuid": "abcdefg"
    }

    headers = {
        "Origin": "https://fanyi.youdao.com",
        "Referer": "https://fanyi.youdao.com",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
        'Host': 'dict.youdao.com',
        'cookie': params.cookies
    }

    url = "https://dict.youdao.com/webtranslate"
    response = requests.post(url, headers=headers, data=data)
    
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 运行 Uvicorn 服务器
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

uvicorn your_script_name:app --reload

@app.get("/")
async def read_root():
    return {"message": "Use POST method for translation"}

@app.post("/")
async def translate(*args, **kwargs):  # 确保这里的参数与你的函数定义一致
    # 你的 POST 请求处理逻辑
    ...

from fastapi import FastAPI, Form

app = FastAPI()

@app.post("/")
async def translate(word: str = Form(...), from_lang: str = Form(...), to_lang: str = Form(...)):
    # 你的处理逻辑
    ...

from fastapi import FastAPI, HTTPException, Response
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 更新后的请求参数模型，所有字段都设置为 str 类型，且为非必需
class TranslationParams(BaseModel):
    word: str = None
    from_lang: str = 'auto'
    to_lang: str = 'auto'
    useTerm: str = 'false'
    cookies: str = '0'

# 省略 sign 和 result 函数的实现...

@app.post("/")
async def translate(params: TranslationParams):
    # 使用 params 模型实例来获取请求参数
    if not params.word:
        raise HTTPException(status_code=400, detail="Word is required")

    # 省略构建请求数据和发送请求的代码...

    # 如果响应状态码为 200，返回解密后的结果
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 省略运行 Uvicorn 服务器的代码...

{
    "word": "Hello, World!",
    "from_lang": "en",
    "to_lang": "es",
    "useTerm": "false",
    "cookies": "your_cookie_string"
}

from fastapi import FastAPI, HTTPException, Response, JSONResponse
from pydantic import BaseModel

app = FastAPI()

class TranslationParams(BaseModel):
    word: str
    from_lang: str = 'auto'
    to_lang: str = 'auto'
    useTerm: str = 'false'
    cookies: str = '0'

@app.post("/")
async def translate(params: TranslationParams):

from fastapi import FastAPI, Query, HTTPException
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 原有的 sign 和 result 函数
# ...

# 更新后的请求参数模型，使用 Query 而不是 Form
class TranslationParams(BaseModel):
    word: str
    from_lang: str = 'auto'
    to_lang: str = 'auto'
    useTerm: str = 'false'
    cookies: str = '0'

# 翻译请求处理
@app.get("/")
async def translate(
    word: str = Query(...),  # 使用 Query 获取 URL 中的参数
    from_lang: str = Query(None, alias='fromLang'),  # 允许使用 fromLang 作为查询参数的别名
    to_lang: str = Query(None, alias='toLang'),
    useTerm: str = Query(None),
    cookies: str = Query(None)
):
    # 检查 word 参数是否传入
    if not word:
        raise HTTPException(status_code=400, detail="Word parameter is required")

    # 构建请求数据
    data = {
        # 省略构建请求数据的代码...
    }

    # 构建请求头
    headers = {
        # 省略构建请求头的代码...
    }

    # 发送请求并处理响应
    # 省略发送请求和处理响应的代码...

    return {"translated_word": "Translated word would be here"}

# 运行 Uvicorn 服务器的代码
# ...

from fastapi import FastAPI, HTTPException, Response
from pydantic import BaseModel
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 更新后的请求参数模型，用于 JSON 请求体
class TranslationParams(BaseModel):
    word: str
    from_lang: str
    to_lang: str
    useTerm: str
    cookies: str

# 原有的 sign 和 result 函数
# ...

# 翻译请求处理
@app.post("/")
async def translate(params: TranslationParams):
    # 从 JSON 请求体中获取参数
    word = params.word
    from_lang = params.from_lang
    to_lang = params.to_lang
    useTerm = params.useTerm
    cookies = params.cookies

    # 省略构建请求数据和发送请求的代码...

    # 发送请求并处理响应
    response = requests.post(url, headers=headers, data=data)
    
    # 如果响应状态码为 200，返回解密后的结果
    if response.status_code == 200:
        return result(response.text)
    else:
        raise HTTPException(status_code=response.status_code, detail="Translation failed")

# 运行 Uvicorn 服务器的代码
# ...

{
    "word": "Hello, World!",
    "from_lang": "en",
    "to_lang": "es",
    "useTerm": "false",
    "cookies": "your_cookie_string"
}

from fastapi import FastAPI, HTTPException, Response
from pydantic import BaseModel, Field
import base64
import time
from Crypto.Cipher import AES
import hashlib
import requests

app = FastAPI()

# 更新后的请求参数模型，用于 JSON 请求体
class TranslationParams(BaseModel):
    source_lang: str = Field(..., example='en')  # 源语言代码
    target_lang: str = Field(..., example='es')  # 目标语言代码
    text_list: list = Field(..., example=['Hello', 'World'])  # 翻译文本数组

# 原有的 sign 和 result 函数
# ...

# 翻译请求处理
@app.post("/translate-batch/")
async def translate_batch(params: TranslationParams):
    # 从 JSON 请求体中获取参数
    source_lang = params.source_lang
    target_lang = params.target_lang
    text_list = params.text_list

    # 翻译每条文本
    translated_texts = []
    for text in text_list:
        # 构建请求数据
        data = {
            "i": text,
            "from": source_lang,
            "to": target_lang,
            # 其他必要的请求参数...
        }

        # 构建请求头
        headers = {
            # 根据需要设置 headers...
        }

        # 假设你已经有了一个发送请求并获取响应的函数
        response = send_translation_request(data, headers)

        # 检查响应状态
        if response.status_code == 200:
            translated_text = result(response.text)
            translated_texts.append(translated_text)
        else:
            translated_texts.append("Translation failed for: " + text)
            continue  # 或者根据需要处理错误

    # 返回翻译结果
    return translated_texts

# 发送翻译请求并获取响应的函数
def send_translation_request(data, headers):
    url = "翻译服务的URL"
    response = requests.post(url, headers=headers, json=data)
    return response

# 运行 Uvicorn 服务器的代码
# ...

{
    "source_lang": "en",
    "target_lang": "es",
    "text_list": ["Hello", "World"]
}

from fastapi import FastAPI, HTTPException, Response
from pydantic import BaseModel, Field
import requests
import hashlib

app = FastAPI()

# 更新后的请求参数模型，用于 JSON 请求体
class TranslationParams(BaseModel):
    source_lang: str = Field(..., example='en')  # 源语言代码
    target_lang: str = Field(..., example='es')  # 目标语言代码
    text_list: list = Field(..., example=['Hello', 'World'])  # 翻译文本数组

# 假设的 send_translation_request 函数，根据实际情况实现
def send_translation_request(text, source_lang, target_lang, headers):
    url = "翻译服务的URL"  # 替换为实际的翻译服务URL
    data = {
        "i": text,
        "from": source_lang,
        "to": target_lang,
        # 其他必要的请求参数...
    }
    response = requests.post(url, headers=headers, json=data)
    return response

# 翻译请求处理
@app.post("/translate-batch/")
async def translate_batch(params: TranslationParams):
    source_lang = params.source_lang
    target_lang = params.target_lang
    text_list = params.text_list

    translations = []
    for text in text_list:
        response = send_translation_request(text, source_lang, target_lang, headers={"Content-Type": "application/json"})

        if response.status_code == 200:
            # 假设翻译服务返回的 JSON 包含 'detected_source_language' 和 'translation' 字段
            detected_source_lang = response.json().get('detected_source_language')
            translated_text = response.json().get('translation')
            translations.append({
                "detected_source_lang": detected_source_lang,
                "text": translated_text
            })
        else:
            # 处理错误情况，这里只是记录失败，具体错误处理根据需要实现
            translations.append({
                "detected_source_lang": "unknown",
                "text": f"Translation failed for: {text}"
            })

    return {"translations": translations}

# 运行 Uvicorn 服务器的代码
# ...

{
    "source_lang": "en",
    "target_lang": "es",
    "text_list": ["Hello", "World"]
}

{
    "translations": [
        {
            "detected_source_lang": "en",
            "text": "Hola"
        },
        {
            "detected_source_lang": "en",
            "text": "Mundo"
        }
    ]
}

# 语言代码映射字典
language_code_map = {
    "auto": "自动检测语言",  # 示例，实际使用时可能需要一个数字标识符或特定值
    "af": "阿非利卡语",
    "am": "阿姆哈拉语",
    # ... 添加所有其他语言代码
    "zu": "祖鲁语",
}

# 函数：根据语言代码获取对应的值
def get_language_code_value(lang_code):
    return language_code_map.get(lang_code.lower())

# 示例：将输入的语言代码转换为对应的语言名称
print(get_language_code_value("en"))  # 输出: 英语

from fastapi import FastAPI, HTTPException, Body
from pydantic import BaseModel

app = FastAPI()

class TranslationRequest(BaseModel):
    source_lang: str = Body(..., example='en')
    target_lang: str = Body(..., example='zh-CN')
    text_list: list = Body(..., example=['Hello World

def map_language_code_to_key(lang_code):
    # 语言代码到数字的映射字典
    lang_map = {
        'auto': 0,  # 假设 0 代表自动检测语言
        'af': 1, 'am': 2, 'ar': 3, 'az': 4, 'be': 5, 'bg': 6,
        'ca': 7, 'ceb': 8, 'co': 9, 'cs': 10, 'cy': 11, 'da': 12,
        'de': 13, 'el': 14, 'en': 15, 'eo': 16, 'es': 17, 'et': 18,
        'eu': 19, 'fa': 20, 'fi': 21, 'fil': 22, 'fj': 23, 'fr': 24,
        # ... 添加所有其他语言代码映射
        'zh-CN': 27, 'zh-TW': 28, 'zu': 29
        # 注意：确保所有数字都是唯一的，并且与原字典中的数字对应
    }
    return lang_map.get(lang_code.lower(), None)  # 使用 lower() 保证大小写不敏感

# 示例用法
source_lang_key = map_language_code_to_key('en')  # 应返回 15
target_lang_key = map_language_code_to_key('zh-CN')  # 应返回 27

@app.post("/translate-batch/")
async def translate_batch(request_data: Request):
    # 解析请求体中的 JSON 数据
    source_lang_code = request_data.json().get('source_lang')
    target_lang_code = request_data.json().get('target_lang')
    text_list = request_data.json().get('text_list')

    # 映射语言代码到数字
    source_lang_key = map_language_code_to_key(source_lang_code)
    target_lang_key = map_language_code_to_key(target_lang_code)

    if source_lang_key is None or target_lang_key is None:
        raise HTTPException(status_code=400, detail="Invalid language code")

    # 接下来使用 source_lang_key 和 target_lang_key 进行翻译...

# 其余代码保持不变

import requests
import json

# 假设这是API的URL
api_url = "http://example.com/api/translate"

# 发送POST请求（或GET请求，取决于API的要求）
response = requests.post(api_url, json={"key": "value"})  # 假设API需要POST请求

# 检查响应的状态码
if response.status_code == 200:
    # 解析JSON响应内容（如果使用requests库，这一步通常会自动完成）
    response_data = response.json()

    # 按照JSON结构访问src字段
    # 首先获取顶层的'translateResult'键对应的列表
    translate_result_list = response_data.get("translateResult", [])

    # 然后遍历这个列表，列表中的每个元素都是一个列表
    for result_list in translate_result_list:
        # 在每个内部列表中，获取第一个元素（一个字典），然后获取'src'键对应的值
        src_value = result_list[0].get("src", "")

        # 打印或处理src字段的值
        print(src_value)
else:
    print(f"Failed to get response, status code: {response.status_code}")

response_text = "这是返回的文本数据，后面多了一个
字符"
clean_text = response_text.replace('
', '')
print(clean_text)

response_text = "这是返回的文本数据，后面多了一个
"
if response_text.endswith('
'):
    clean_text = response_text[:-1]
print(clean_text)

# 假设 response_data 是从 API 响应解析得到的字典
translate_result_list = response_data.get("translateResult", [])
for result_list in translate_result_list:
    src_value = result_list[0].get("src", "")
    # 去除 src_value 中的 
 字符
    clean_src_value = src_value.replace('
', '')
    # 打印或处理清洁后的 src 字段的值
    print(clean_src_value)

# 假设 response_data 是从 API 响应解析得到的字典
response_data = {
    "code": 0,
    "translateResult": [
        [[{"src": "src1"}]],
        [[{"src": "src2"}]],
        # ... 可能还有更多的内部数组
    ]
}

# 初始化一个列表来存储所有清理后的 src 值
all_src_values = []

# 遍历最外层数组
for inner_array in response_data.get("translateResult", []):
    # 访问第一个内部数组
    first_inner_array = inner_array[0]
    # 遍历内部数组中的字典对象
    for item in first_inner_array:
        # 获取 src 字段的值，并去除可能存在的 
 字符
        src_value = item.get("src", "").replace('
', '')
        # 将清理后的 src 值添加到列表中
        all_src_values.append(src_value)

# 打印或处理所有 src 值
for src in all_src_values:
    print(src)

from fastapi import FastAPI, Body
from pydantic import BaseModel, Field

app = FastAPI()

class TranslationRequest(BaseModel):
    source_lang: str = Field(..., example='en', description='Source language code')
    target_lang: str = Field(..., example='es', description='Target language code')
    text_list: list = Field(..., example=['Hello', 'World'], description='List of texts to translate')

    class Config:
        from_pydantic = ...

@app.post("/translate/")
async def translate(request: TranslationRequest = Body(..., embed=True)):
    # 你的处理逻辑
    pass

{
    "source_lang": "en",
    "target_lang": "es",
    "text_list": ["Hello", "World"]
}

import json

# 假设你有一个 JSON 格式的字符串
json_string = '{"name": "John", "age": 30, "city": "New York"}'

# 使用 json.loads() 函数将 JSON 字符串转换为 Python 字典
python_dict = json.loads(json_string)

print(python_dict)
print(type(python_dict))

import json

# 假设我们有一个JSON格式的字符串
json_string = '{"name": "John", "age": 30, "city": "New York"}'

# 使用 json.loads() 将字符串转换为字典
python_dict = json.loads(json_string)

# 打印转换后的字典
print(python_dict)

# JSON 数组格式的字符串
json_array_string = '["apple", "banana", "cherry"]'

# 使用 json.loads() 将数组字符串转换为列表
python_list = json.loads(json_array_string)

# 打印转换后的列表
print(python_list)

for item in python_list:
    print(item)

apple
banana
cherry

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import json

app = FastAPI()

class Item(BaseModel):
    name: str

@app.post("/items/")
async def create_items(items: list):
    # items 已经是一个Python列表
    for item in items:
        # 处理每个Item
        print(item.name)
    return items

[
    {"name": "apple"},
    {"name": "banana"},
    {"name": "cherry"}
]