变量只是一个名字,真正参与计算、拼接、判断和传输的是它当前指向的数据对象。数据对象的类型决定了它能做什么:数字可以相加,字符串可以拼接,列表可以追加元素,字典可以通过键找到值。
1price = 30 2name = "Python" 3topics = ["变量", "模块"] 4 5print(price + 10) 6print(name.lower()) 7topics.append("数据类型") 8print(topics)
如果不清楚一个值的类型,就很容易出现这类错误:把数字当成字符串拼接,把列表当成字典读取,或者把 None 当成已经存在的结果。学习数据类型,是为了知道每种数据应该如何使用
int 表示整数,float 表示带小数的浮点数,complex 表示复数。日常的 FastAPI 和 LangChain 代码中,最常使用的是前两种:
int
float
complex
1count = 3 2ratio = 0.75 3 4print(count + 2) 5print(ratio * 100) 6print(type(count)) # <class 'int'> 7print(type(ratio)) # <class 'float'>
Python 的整数不会被固定在 32 位或 64 位范围内,通常会根据可用内存自动扩展。浮点数适合表示一般的小数,但由于计算机使用二进制保存浮点数,金额等对精度要求很高的场景不应直接依赖普通 float。
需要精确计算金额时,可以使用 decimal.Decimal:
decimal.Decimal
1from decimal import Decimal 2 3price = Decimal("0.10") 4quantity = 3 5 6print(price * quantity) # 0.30
布尔类型只有两个值:True 和 False。它通常用于条件判断、开关配置和接口状态:
True
False
1debug = True 2is_authenticated = False 3 4if debug: 5 print("当前处于调试模式") 6 7if not is_authenticated: 8 print("请先登录")
Python 中 False、None、数字 0、空字符串、空列表、空字典等值,在条件判断里会被当作“假”;其他大多数值会被当作“真”。这种规则叫真值判断:
None
0
1values = [0, "", [], "Python", [1]] 2 3for value in values: 4 if value: 5 print(f"{value!r} 会被当作真")
不要把“真值判断”和“类型是 bool”混为一谈。空字符串的类型仍然是 str,只是它在 if 中表现为假。
bool
str
if
字符串表示文本,可以使用单引号或双引号。项目中建议统一一种写法,避免同一文件中风格混杂:
1course = "LangChain Python" 2 3print(course[0]) # L 4print(course[0:9]) # LangChain 5print(course.lower()) # langchain python 6print(len(course)) # 16
字符串是不可变对象。lower()、replace() 等方法返回处理后的字符串,原字符串保持不变:
lower()
replace()
1message = "Hello" 2new_message = message.upper() 3 4print(message) # Hello 5print(new_message) # HELLO
拼接变量和文本时,优先使用 f-string:
1name = "小微" 2topic = "数据类型" 3 4message = f"你好,{name},今天学习{topic}。" 5print(message) # 你好,小微,今天学习数据类型。
None 表示“没有值”或“目前还没有结果”,它不是字符串,也不是数字:
1result = None 2 3if result is None: 4 print("查询还没有完成")
判断空值时使用 is None,而不是把它写成字符串 "None"。在 FastAPI 接口中,数据库里没有找到的可选字段,也经常用 None 表示:
is None
"None"
1nickname = None 2 3response = { 4 "nickname": nickname, 5} 6 7print(response) # {'nickname': None}
容器用于保存多个值。它们的区别主要体现在顺序、是否允许重复、是否可以修改,以及如何读取数据:
list
["Python", "FastAPI"]
tuple
("Python", "FastAPI")
set
{ "Python", "FastAPI" }
dict
{ "name": "小微" }
列表通过下标读取,下标从 0 开始:
1topics = ["变量", "模块"] 2topics.append("数据类型") 3 4print(topics[0]) 5print(topics)
元组常用圆括号表示,创建后不能直接追加或替换其中的元素;元素之间的逗号决定了元组的结构。元组也可以包含可变对象,例如列表,这些对象内部的内容仍然可以修改:
1coordinate = (120.1, 30.2) 2 3print(coordinate[0]) 4# coordinate[0] = 121.0 # TypeError:元组不能修改
集合会自动去重,但不适合依赖元素的下标:
1tags = {"python", "fastapi", "python"} 2 3print(tags) # {'python', 'fastapi'},顺序不作为业务依据
字典通过键读取值,键通常使用字符串:
1profile = { 2 "name": "小微", 3 "age": 18, 4} 5 6print(profile["name"]) 7profile["city"] = "杭州"
在 JavaScript 的入门教材中,经常把数据分为“基础类型”和“引用类型”。这个说法用于帮助理解 JavaScript 的行为,但 Python 没有一套完全对应的官方类型分类。
在 Python 中,整数、字符串、列表、字典和函数都是对象。变量名不是一个固定大小的盒子,而是指向对象的名字:
1number = 18 2message = "Python" 3 4print(type(number)) 5print(type(message))
理解 Python 数据时,我们可以思考两个问题:这个名字当前指向什么类型的对象?这个对象能不能在原地修改?
因此,当执行 second = first 时,Python 会让两个名字指向同一个对象,不会自动复制一份:
second = first
1first = ["Python"] 2second = first 3 4second.append("LangChain") 5 6print(first) # ['Python', 'LangChain'] 7print(second) # ['Python', 'LangChain'] 8print(first is second) # True
is 比较的是两个名字是否指向同一个对象,== 比较的是两个对象的值是否相等:
is
==
1first = ["Python"] 2second = ["Python"] 3 4print(first == second) # True:内容相同 5print(first is second) # False:不是同一个列表对象
整数、浮点数、布尔值、字符串和元组都是常见的不可变对象。下面的字符串拼接会得到结果字符串,再让变量名指向这个结果,原字符串保持不变:
1message = "你好" 2old_message = message 3message += ",小微" 4 5print(old_message) # 你好 6print(message) # 你好,小微 7print(old_message is message) # False
列表、字典和集合是常见的可变对象。调用 append()、修改字典键或向集合中添加元素,会直接改变原对象:
append()
1profile = {"name": "小微"} 2same_profile = profile 3 4same_profile["age"] = 18 5 6print(profile) # {'name': '小微', 'age': 18} 7print(profile is same_profile) # True
这就是 Python 中最重要的区别:不是“某类变量保存值、另一类变量保存引用”,而是所有变量名都绑定对象,只是对象有的能修改,有的不能修改。
如果想让两个列表互不影响,需要显式创建副本
1topics = ["变量"] 2copied_topics = topics.copy() 3 4copied_topics.append("JSON") 5 6print(topics) # ['变量'] 7print(copied_topics) # ['变量', 'JSON']
copy() 只复制当前这一层。如果列表中还有嵌套列表或字典,还需要根据数据结构决定使用 copy.deepcopy(),或者重新设计数据的创建方式。初学时先记住:给一个新变量赋值,不等于复制
copy()
copy.deepcopy()
JSON 是一种文本格式,用于在浏览器、FastAPI 服务和其他程序之间传输结构化数据。JSON 支持六类值:
{}
[]
true
false
下面是一段合法的 JSON:
01{ 02 "name": "小微", 03 "age": 18, 04 "isStudent": true, 05 "skills": ["Python", "FastAPI"], 06 "profile": { 07 "city": "杭州" 08 }, 09 "lastLogin": null 10}
最外层的 {} 表示一个对象,里面的每一项都是 "键": 值。值可以继续是数组或对象,因此 JSON 可以表达嵌套结构。
"键": 值
JSON 对语法比较严格:键和字符串必须使用双引号,不能写注释,最后一项后面不能多逗号。下面这些写法不是标准 JSON:
1{ name: '小微' } # 键没有双引号,字符串用了单引号 2{ "age": 18, } # 最后一项后面多了逗号 3{ "enabled": True } # JSON 使用 true,不是 Python 的 True
Python 中最接近 JSON 对象的是 dict,最接近 JSON 数组的是 list:
1user = { 2 "name": "小微", 3 "age": 18, 4 "is_student": True, 5 "skills": ["Python", "FastAPI"], 6 "last_login": None, 7}
两者并不是完全相同的语法。常见对应关系如下:
null
Python 的 dict 可以使用整数、元组等可哈希对象作为键,但 JSON 对象的键应当使用字符串。为了让接口行为稳定,定义准备发送给前端的字典时,直接使用字符串键。
json.dumps() 把 Python 对象转换成 JSON 字符串,json.loads() 把 JSON 字符串解析回 Python 对象:
json.dumps()
json.loads()
01import json 02 03user = { 04 "name": "小微", 05 "is_student": True, 06 "last_login": None, 07} 08 09json_text = json.dumps(user, ensure_ascii=False) 10print(json_text) 11 12parsed_user = json.loads(json_text) 13print(parsed_user["name"]) 14print(type(parsed_user)) # <class 'dict'>
dumps() 的返回值是 str,可以写入文件或作为序列化后的文本传输。loads() 接受表示合法 JSON 的 str、bytes 或 bytearray;JSON 对象解析为 dict,数组解析为 list,最外层也可以是字符串、数字、布尔值或 null,因此解析结果不一定是字典或列表。
dumps()
loads()
bytes
bytearray
集合不能直接转换为 JSON:
1import json 2 3tags = {"python", "fastapi"} 4 5# json.dumps(tags) # TypeError:set 不是 JSON 支持的类型 6json_text = json.dumps(sorted(tags)) 7print(json_text)
在转换前把集合明确变成列表,才能决定输出顺序和接口含义,而不是依赖某种偶然的集合遍历顺序。
FastAPI 的接口通常接收 JSON 请求体,再返回 JSON 响应。使用 Pydantic 模型可以声明请求数据的结构和类型:
01from fastapi import FastAPI 02from pydantic import BaseModel 03 04app = FastAPI() 05 06# 定义请求数据结构 07class ChatRequest(BaseModel): 08 question: str 09 temperature: float = 0.2 10 stream: bool = False 11 12@app.post("/chat") 13async def chat(request: ChatRequest) -> dict[str, object]: 14 return { 15 "question": request.question, 16 "temperature": request.temperature, 17 "stream": request.stream, 18 }
客户端发送的 JSON 可以这样写:
1{ 2 "question": "请介绍 Python 的字典。", 3 "temperature": 0.2, 4 "stream": false 5}
FastAPI 会把请求体解析成 ChatRequest 对象,request.question 是字符串,request.temperature 是浮点数,request.stream 是布尔值。返回的 Python dict 会被 FastAPI 转换为 JSON:False 会变成 false,None 会变成 null。
ChatRequest
request.question
request.temperature
request.stream
Pydantic 默认会尝试进行符合规则的类型转换,例如把合法的数字字符串转换成浮点数。无法转换或不满足字段约束时,FastAPI 才会在进入函数前返回 HTTP 422 校验错误。这些声明让处理函数拿到符合要求的数据,也让接口文档能够展示清楚的结构。
type() 可以查看一个对象的具体类型,isinstance() 可以在业务代码中判断一个值是否属于某个类型或类型集合:
type()
isinstance()
1value = "Python" 2 3print(type(value)) 4print(isinstance(value, str)) 5print(isinstance(value, (list, tuple)))
通常不要把 type(value) == str 当成唯一的类型判断方式。isinstance() 能正确处理继承关系,也更方便同时接受多个类型。
type(value) == str
Python 提供了多种构造函数进行转换,也有 repr()、ord() 等常用的表示或编码辅助函数:
repr()
ord()
int(x [,base])
float(x)
complex(real [,imag])
str(x)
repr(x)
tuple(s)
list(s)
set(s)
dict(d)
frozenset(s)
chr(x)
ord(x)
hex(x)
oct(x)
Python 3 使用 int 表示整数,chr() 处理 Unicode 码点,不再使用 Python 2 的 long() 和 unichr()。eval() 会执行表达式,不适合作为用户输入的通用类型转换方式;这里的转换使用明确的构造函数。
chr()
long()
unichr()
eval()
1age_text = "18" 2age = int(age_text) 3score = float("98.5") 4message = str(age) 5 6print(age + 2) 7print(score) 8print(message)
转换不是总能成功。int("十八") 会抛出 ValueError,所以处理用户输入时,应当做好异常处理或交给 Pydantic 校验:
int("十八")
ValueError
1try: 2 age = int("十八") 3except ValueError: 4 age = None 5 6print(age)
本篇在线实验沿用请求字段的例子,把类型检查、真值判断、容器和 JSON 转换放在一起观察。这个接口只检查和回显数据,不调用模型,也不需要密钥。
main.py 提供接口,把请求数据交给主题文件。完整入口代码如下:
main.py
01from fastapi import FastAPI 02from pydantic import BaseModel, Field 03 04from data_types import build_type_report 05 06app = FastAPI() 07 08class DataRequest(BaseModel): 09 question: str = Field(min_length=1, max_length=500) 10 temperature: float = Field(default=0.2, ge=0, le=2) 11 stream: bool = False 12 nickname: str | None = Field(default=None, max_length=40) 13 14@app.post("/types") 15async def inspect_types(request: DataRequest) -> dict[str, object]: 16 report = build_type_report(request.question, request.temperature, request.stream, request.nickname) 17 print(f"问题类型:{report['python_types']['question']};字符串长度:{report['string']['length']}") 18 print(f"Decimal 金额:{report['numbers']['money_total']}") 19 return report 20
实验保存在 data_types.py 中。这里展示的代码与在线工作区的原始文件直接共用同一份来源:
data_types.py
01import json 02from decimal import Decimal 03 04def build_type_report(question: str, temperature: float, stream: bool, nickname: str | None) -> dict[str, object]: 05 course = "LangChain Python" 06 topics = ["变量", "模块"] 07 topics.append("数据类型") 08 coordinate = (120.1, 30.2) 09 tags = {"python", "fastapi", "python"} 10 sorted_tags = sorted(tags) 11 profile = { 12 "question": question, 13 "temperature": temperature, 14 "stream": stream, 15 "nickname": nickname, 16 } 17 18 truth_values = [0, "", [], "Python", [1]] 19 truthiness = [] 20 for value in truth_values: 21 truthiness.append({"value": value, "type": type(value).__name__, "is_truthy": bool(value)}) 22 23 json_text = json.dumps(profile, ensure_ascii=False) 24 parsed_profile = json.loads(json_text) 25 age = int("18") 26 try: 27 invalid_age = int("十八") 28 except ValueError as error: 29 conversion_error = type(error).__name__ 30 else: 31 conversion_error = "" 32 33 return { 34 "python_types": { 35 "question": type(question).__name__, 36 "temperature": type(temperature).__name__, 37 "stream": type(stream).__name__, 38 "nickname": type(nickname).__name__, 39 }, 40 "numbers": {"count": 3, "ratio": 0.75, "money_total": str(Decimal("0.10") * 3)}, 41 "string": {"value": course, "first": course[0], "prefix": course[:9], "length": len(course)}, 42 "truthiness": truthiness, 43 "containers": { 44 "topics": topics, 45 "coordinate": {"python_type": type(coordinate).__name__, "json_value": list(coordinate)}, 46 "tags": sorted_tags, 47 "unique_tag_count": len(tags), 48 "profile": profile, 49 }, 50 "json": {"text": json_text, "parsed": parsed_profile, "parsed_type": type(parsed_profile).__name__}, 51 "conversion": {"age": age, "age_plus_two": age + 2, "invalid_integer": conversion_error}, 52 } 53
打开在线案例,点击运行,等待环境就绪。案例预览默认使用 POST /types,请求体是:
POST /types
点击发送后,响应中会包含完整实验结果。先看下面几组关键字段:
1{ 2 "python_types": {"question": "str", "temperature": "float", "stream": "bool", "nickname": "NoneType"}, 3 "numbers": {"count": 3, "ratio": 0.75, "money_total": "0.30"}, 4 "string": {"value": "LangChain Python", "first": "L", "prefix": "LangChain", "length": 16}, 5 "conversion": {"age": 18, "age_plus_two": 20, "invalid_integer": "ValueError"} 6}
金额使用 Decimal 计算,并明确转成字符串返回,因此 money_total 是 "0.30"。集合先经过 sorted() 转成列表,结果为 ["fastapi", "python"];元组也明确转成列表输出,同时保留 python_type 说明它在 Python 中的原始类型。这样可以看出程序内部的数据类型和 JSON 的表达方式有哪些差别。
Decimal
money_total
"0.30"
sorted()
["fastapi", "python"]
python_type
int("十八") 的错误在主题文件中被捕获,conversion.invalid_integer 中的 "ValueError" 是预期实验结果,整个请求仍然正常返回。日志会打印字段类型、字符串长度和金额结果。
conversion.invalid_integer
"ValueError"
接下来可以给请求体增加 "nickname": "小微",观察它的类型从 NoneType 变为 str;也可以把 temperature 改成字符串 "0.2",把 stream 改成字符串 "false"。Pydantic 默认会把这两种合法输入转换成浮点数和布尔值。改成无法转换的内容或超出字段范围时,接口会返回 HTTP 422,请求不会进入实验函数。
"nickname": "小微"
NoneType
temperature
"0.2"
stream
"false"
下载并解压项目,在项目目录执行:
1uv run fastapi dev main.py
然后打开 http://127.0.0.1:8000/docs,选择 POST /types,填写上面的请求体并发送。
http://127.0.0.1:8000/docs
浏览器使用当前 Pyodide 的 Python 环境,本机使用 .python-version 指定的版本。在线模式无需启动本机端口,也不需要模型密钥。本篇的文件草稿、日志、Git 配置和 PI Agent 对话独立保存,依赖下载缓存可与同站其他文章共享。
.python-version
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 概览
变量只是一个名字,真正参与计算、拼接、判断和传输的是它当前指向的数据对象。数据对象的类型决定了它能做什么:数字可以相加,字符串可以拼接,列表可以追加元素,字典可以通过键找到值。
如果不清楚一个值的类型,就很容易出现这类错误:把数字当成字符串拼接,把列表当成字典读取,或者把 None 当成已经存在的结果。学习数据类型,是为了知道每种数据应该如何使用
2. 数字
int表示整数,float表示带小数的浮点数,complex表示复数。日常的 FastAPI 和 LangChain 代码中,最常使用的是前两种:Python 的整数不会被固定在 32 位或 64 位范围内,通常会根据可用内存自动扩展。浮点数适合表示一般的小数,但由于计算机使用二进制保存浮点数,金额等对精度要求很高的场景不应直接依赖普通
float。需要精确计算金额时,可以使用
decimal.Decimal:3. 布尔
布尔类型只有两个值:
True和False。它通常用于条件判断、开关配置和接口状态:Python 中
False、None、数字0、空字符串、空列表、空字典等值,在条件判断里会被当作“假”;其他大多数值会被当作“真”。这种规则叫真值判断:不要把“真值判断”和“类型是
bool”混为一谈。空字符串的类型仍然是str,只是它在if中表现为假。4. 字符串
字符串表示文本,可以使用单引号或双引号。项目中建议统一一种写法,避免同一文件中风格混杂:
字符串是不可变对象。
lower()、replace()等方法返回处理后的字符串,原字符串保持不变:拼接变量和文本时,优先使用 f-string:
5. 空值
None表示“没有值”或“目前还没有结果”,它不是字符串,也不是数字:判断空值时使用
is None,而不是把它写成字符串"None"。在 FastAPI 接口中,数据库里没有找到的可选字段,也经常用None表示:6. 容器
容器用于保存多个值。它们的区别主要体现在顺序、是否允许重复、是否可以修改,以及如何读取数据:
list["Python", "FastAPI"]tuple("Python", "FastAPI")set{ "Python", "FastAPI" }dict{ "name": "小微" }列表通过下标读取,下标从
0开始:元组常用圆括号表示,创建后不能直接追加或替换其中的元素;元素之间的逗号决定了元组的结构。元组也可以包含可变对象,例如列表,这些对象内部的内容仍然可以修改:
集合会自动去重,但不适合依赖元素的下标:
字典通过键读取值,键通常使用字符串:
7. 对象
在 JavaScript 的入门教材中,经常把数据分为“基础类型”和“引用类型”。这个说法用于帮助理解 JavaScript 的行为,但 Python 没有一套完全对应的官方类型分类。
在 Python 中,整数、字符串、列表、字典和函数都是对象。变量名不是一个固定大小的盒子,而是指向对象的名字:
理解 Python 数据时,我们可以思考两个问题:这个名字当前指向什么类型的对象?这个对象能不能在原地修改?
因此,当执行
second = first时,Python 会让两个名字指向同一个对象,不会自动复制一份:is比较的是两个名字是否指向同一个对象,==比较的是两个对象的值是否相等:整数、浮点数、布尔值、字符串和元组都是常见的不可变对象。下面的字符串拼接会得到结果字符串,再让变量名指向这个结果,原字符串保持不变:
列表、字典和集合是常见的可变对象。调用
append()、修改字典键或向集合中添加元素,会直接改变原对象:这就是 Python 中最重要的区别:不是“某类变量保存值、另一类变量保存引用”,而是所有变量名都绑定对象,只是对象有的能修改,有的不能修改。
如果想让两个列表互不影响,需要显式创建副本
copy()只复制当前这一层。如果列表中还有嵌套列表或字典,还需要根据数据结构决定使用copy.deepcopy(),或者重新设计数据的创建方式。初学时先记住:给一个新变量赋值,不等于复制8. JSON
JSON 是一种文本格式,用于在浏览器、FastAPI 服务和其他程序之间传输结构化数据。JSON 支持六类值:
{},由字符串键和值组成;[],保存有顺序的一组值;true或false;下面是一段合法的 JSON:
最外层的
{}表示一个对象,里面的每一项都是"键": 值。值可以继续是数组或对象,因此 JSON 可以表达嵌套结构。JSON 对语法比较严格:键和字符串必须使用双引号,不能写注释,最后一项后面不能多逗号。下面这些写法不是标准 JSON:
Python 中最接近 JSON 对象的是
dict,最接近 JSON 数组的是list:两者并不是完全相同的语法。常见对应关系如下:
dictlist、tuplestrint、floatTrue、Falsetrue、falseNonenullsetPython 的
dict可以使用整数、元组等可哈希对象作为键,但 JSON 对象的键应当使用字符串。为了让接口行为稳定,定义准备发送给前端的字典时,直接使用字符串键。9. JSON 转换
json.dumps()把 Python 对象转换成 JSON 字符串,json.loads()把 JSON 字符串解析回 Python 对象:dumps()的返回值是str,可以写入文件或作为序列化后的文本传输。loads()接受表示合法 JSON 的str、bytes或bytearray;JSON 对象解析为dict,数组解析为list,最外层也可以是字符串、数字、布尔值或null,因此解析结果不一定是字典或列表。集合不能直接转换为 JSON:
在转换前把集合明确变成列表,才能决定输出顺序和接口含义,而不是依赖某种偶然的集合遍历顺序。
10. FastAPI
FastAPI 的接口通常接收 JSON 请求体,再返回 JSON 响应。使用 Pydantic 模型可以声明请求数据的结构和类型:
客户端发送的 JSON 可以这样写:
FastAPI 会把请求体解析成
ChatRequest对象,request.question是字符串,request.temperature是浮点数,request.stream是布尔值。返回的 Pythondict会被 FastAPI 转换为 JSON:False会变成false,None会变成null。Pydantic 默认会尝试进行符合规则的类型转换,例如把合法的数字字符串转换成浮点数。无法转换或不满足字段约束时,FastAPI 才会在进入函数前返回 HTTP 422 校验错误。这些声明让处理函数拿到符合要求的数据,也让接口文档能够展示清楚的结构。
11. 操作
type()可以查看一个对象的具体类型,isinstance()可以在业务代码中判断一个值是否属于某个类型或类型集合:通常不要把
type(value) == str当成唯一的类型判断方式。isinstance()能正确处理继承关系,也更方便同时接受多个类型。12. 类型转换
Python 提供了多种构造函数进行转换,也有
repr()、ord()等常用的表示或编码辅助函数:int(x [,base])float(x)complex(real [,imag])str(x)repr(x)tuple(s)list(s)set(s)dict(d)frozenset(s)chr(x)ord(x)hex(x)oct(x)Python 3 使用
int表示整数,chr()处理 Unicode 码点,不再使用 Python 2 的long()和unichr()。eval()会执行表达式,不适合作为用户输入的通用类型转换方式;这里的转换使用明确的构造函数。转换不是总能成功。
int("十八")会抛出ValueError,所以处理用户输入时,应当做好异常处理或交给 Pydantic 校验:13. 在线实验
本篇在线实验沿用请求字段的例子,把类型检查、真值判断、容器和 JSON 转换放在一起观察。这个接口只检查和回显数据,不调用模型,也不需要密钥。
main.py提供接口,把请求数据交给主题文件。完整入口代码如下:实验保存在
data_types.py中。这里展示的代码与在线工作区的原始文件直接共用同一份来源:13.1 运行并观察
打开在线案例,点击运行,等待环境就绪。案例预览默认使用
POST /types,请求体是:点击发送后,响应中会包含完整实验结果。先看下面几组关键字段:
金额使用
Decimal计算,并明确转成字符串返回,因此money_total是"0.30"。集合先经过sorted()转成列表,结果为["fastapi", "python"];元组也明确转成列表输出,同时保留python_type说明它在 Python 中的原始类型。这样可以看出程序内部的数据类型和 JSON 的表达方式有哪些差别。int("十八")的错误在主题文件中被捕获,conversion.invalid_integer中的"ValueError"是预期实验结果,整个请求仍然正常返回。日志会打印字段类型、字符串长度和金额结果。接下来可以给请求体增加
"nickname": "小微",观察它的类型从NoneType变为str;也可以把temperature改成字符串"0.2",把stream改成字符串"false"。Pydantic 默认会把这两种合法输入转换成浮点数和布尔值。改成无法转换的内容或超出字段范围时,接口会返回 HTTP 422,请求不会进入实验函数。13.2 本机运行
下载并解压项目,在项目目录执行:
然后打开
http://127.0.0.1:8000/docs,选择POST /types,填写上面的请求体并发送。浏览器使用当前 Pyodide 的 Python 环境,本机使用
.python-version指定的版本。在线模式无需启动本机端口,也不需要模型密钥。本篇的文件草稿、日志、Git 配置和 PI Agent 对话独立保存,依赖下载缓存可与同站其他文章共享。