变量是给数据起的名字。我们不必每次都直接面对一段字符串、一个数字或一组列表,而是先给它一个容易理解的名字,后面通过这个名字使用数据。
1name = "小微" 2age = 18 3 4print(name) 5print(age)
这里的 name 和 age 就是变量,"小微" 和 18 是它们当前指向的数据。
name
age
"小微"
18
初学时可以先把 name = "小微" 读成“让变量 name 指向字符串 "小微"”。等理解了这个关系,就不容易把 Python 变量误解成只能存放一种固定类型的盒子。
name = "小微"
Python 使用等号 = 进行赋值。第一次给一个名字赋值时,这个名字就创建出来了;之后再次赋值,就是让它指向新的数据。
=
1message = "欢迎学习 Python" 2print(message) 3 4message = "今天继续学习变量" 5print(message)
第二次赋值不会修改原来的字符串,而是让 message 改为指向新的字符串。变量名相同,当前指向的数据可以不同。
message
第一次赋值让 message 指向字符串“欢迎学习 Python”。第二次赋值让同一个变量名改为指向“今天继续学习变量”。旧字符串没有被修改;图中上下两行表示赋值前后的两个时刻。
BEFORE / 第一次赋值
AFTER / 再次赋值
同一个变量名
“欢迎学习 Python”
不可变字符串对象
改变当前指向
“今天继续学习变量”
另一个字符串对象
变量的值可以参与计算、拼接和条件判断:
1price = 30 2quantity = 2 3total = price * quantity 4 5print(f"总价是 {total} 元")
等号右边先计算,得到结果后再赋给等号左边的变量。因此,total 保存的是 price * quantity 的计算结果。
total
price * quantity
如果直接读取一个还没有创建的变量,Python 会抛出 NameError:
NameError
1print(username) # NameError:username 还没有定义
把变量放在使用它的代码之前,是最简单也最可靠的习惯。上面这段代码是单独观察错误的例子,执行时会停止在 NameError;后面的完整服务没有加入这条语句,避免启动时就被中断。
在一些语言中,创建变量时要先写明它只能保存什么类型。Python 不需要这样做:
1score = 100 2name = "小微" 3enabled = True
类型属于对象。赋值时,变量名与右侧的对象建立关联,同一个名字可以先后指向不同类型的对象。因此,下面的代码是合法的:
1value = 18 2print(type(value)) 3 4value = "十八" 5print(type(value))
这体现了 Python 的动态类型:变量名没有预先固定的类型,程序在运行时根据当前对象处理操作。这里 value 从整数对象改为指向字符串对象,原来的整数并没有变成字符串。这样的写法比较灵活,拼写错误或不兼容的操作也往往要到执行时才会暴露。
value
Python 中的操作仍然要遵守类型规则。比如,数字和字符串不能直接相加:
1age = 18 2message = "年龄:" + age # TypeError
需要先明确转换类型,或者使用 f-string 进行拼接:
1age = 18 2 3message = "年龄:" + str(age) 4print(message) 5 6print(f"年龄:{age}")
Python 的这种表现通常被称为强类型:操作需要满足相应的类型规则,不兼容时会报错。不同类型也可能按明确的规则一起运算,例如 1 + 1.5 会得到 2.5,因此不能把强类型理解成“不同类型一律不能参与同一个操作”。动态类型描述变量与对象在运行时的关系,强类型描述操作对类型的要求,这两个特点可以同时成立。
1 + 1.5
2.5
需要特别注意:变量名保存的是对象引用
在 Python 中,变量更像一个标签,贴在对象上。多个变量可以同时指向同一个对象:
1languages = ["Python"] 2another_name = languages 3 4another_name.append("LangChain") 5print(languages) # ['Python', 'LangChain']
another_name = languages 没有复制列表,而是让两个名字指向同一个列表对象。因此通过其中一个名字修改列表,另一个名字看到的内容也会改变。
another_name = languages
这也是 Python 中“赋值”和“复制”需要区分的原因。如果确实需要一份独立的列表,可以显式复制:
1languages = ["Python"] 2another_name = languages.copy() 3 4another_name.append("LangChain") 5print(languages) # ['Python'] 6print(another_name) # ['Python', 'LangChain']
copy() 复制的是外层列表,属于浅复制。这个例子中的元素都是不可变字符串,给副本追加内容不会改变原列表;如果元素里还有列表或字典,内层对象仍然可能被两份列表共享。下一篇学习具体数据类型时,我们会继续讨论这些区别。
copy()
变量名没有固定类型,它当前指向的对象有类型。type() 可以查看对象类型,isinstance() 可以判断对象是否属于某个类型:
type()
isinstance()
1value = 18 2 3print(type(value)) 4print(isinstance(value, int)) 5print(isinstance(value, str))
这种设计也支持 Python 常见的鸭子类型思想:函数通常关心对象能做什么,而不是它具体属于哪个类。例如,只要对象支持 len(),就可以传给下面的函数:
len()
1def show_length(value): 2 return len(value) 3 4print(show_length("Python")) 5print(show_length(["FastAPI", "LangChain"]))
有些对象创建后不能直接修改自身的值,这类对象叫不可变对象,例如整数、字符串和元组。字符串拼接会得到一个结果字符串,再把变量名与这个结果关联起来,原字符串保持不变:
1message = "你好" 2message += ",小微" 3print(message)
列表和字典属于常见的可变对象,可以在原对象上修改内容:
1tasks = ["阅读"] 2tasks.append("写代码") 3print(tasks) # ['阅读', '写代码']
理解这一区别很重要:重新给变量赋值,是改变变量名的指向;调用 append() 这类方法,是直接修改可变对象本身。
append()
变量名必须遵守几条语法规则:
Name
if
for
class
def
1user_name = "小微" # 推荐:使用下划线分隔单词 2user2 = "小明" # 可以:数字不能放在开头 3 4# 2users = "错误" # 错误:不能以数字开头 5# user-name = "错误" # 错误:连字符会被解释为减号
除了语法规则,项目还需要统一命名习惯。Python 社区通常使用 snake_case 命名变量和函数,使用大写字母加下划线表示希望保持不变的常量:
snake_case
1DEFAULT_TIMEOUT = 30 2user_name = "小微" 3 4def build_message(user_name: str) -> str: 5 return f"你好,{user_name}!"
DEFAULT_TIMEOUT 只是命名约定,Python 不会阻止别人重新给它赋值。大写名称的作用是提醒协作者:这个值在程序运行期间最好不要修改。
DEFAULT_TIMEOUT
变量可以指向各种对象,最常见的类型包括:
int
float
3.14
str
"Python"
bool
True
False
NoneType
None
list
["Python", "FastAPI"]
tuple
("Python", "FastAPI")
dict
{"name": "小微"}
元组的不可变指的是其中各个位置保存的对象引用不能替换。元组也可以包含列表,这个列表内部的内容仍然可以改变;元组本身不可变,并不保证它包含的所有对象都不可变。
1name = "小微" 2skills = ["Python", "FastAPI"] 3profile = {"name": name, "skills": skills} 4last_login = None 5 6print(profile["name"]) 7print(last_login)
None 不是字符串,也不是数字。它通常用来表示“还没有结果”“暂时未知”或“这里有意留空”。判断它时,推荐使用 is None:
is None
1if last_login is None: 2 print("用户还没有登录记录")
Python 支持在一行中给多个变量赋值:
1first_name, last_name = "小", "微" 2print(first_name, last_name)
等号右侧的内容会按照顺序交给左侧的变量。这种写法叫解包;这里处理的是序列,可迭代对象也支持解包。它还可以用来交换两个变量的值:
1left = "左边" 2right = "右边" 3 4left, right = right, left 5print(left) # 右边 6print(right) # 左边
如果左右数量对不上,Python 会提示解包数量错误。需要接收剩余内容时,可以使用带星号的变量:
1first, *middle, last = [1, 2, 3, 4] 2print(first) # 1 3print(middle) # [2, 3] 4print(last) # 4
上一篇学习了模块拆分,这一篇继续用两个 Python 文件组织案例:variables.py 保存变量实验,main.py 导入其中的 build_report(),负责提供接口。
variables.py
main.py
build_report()
默认的 GET /variables 会返回实验结果,不需要模型密钥。可选的 POST /chat 则通过变量读取模型配置、保存请求内容和模型回复。模型对象在收到 /chat 请求后才创建;没有填写密钥时,这个接口会返回配置说明,变量实验仍然可以运行。
GET /variables
POST /chat
/chat
01import os 02 03from fastapi import FastAPI, HTTPException 04from pydantic import BaseModel 05from langchain_openai import ChatOpenAI 06 07from variables import build_report 08 09app = FastAPI() 10 11class ChatRequest(BaseModel): 12 question: str 13 14@app.get("/variables") 15async def variables(name: str = "小微", price: int = 30, quantity: int = 2) -> dict[str, object]: 16 report = build_report(name, price, quantity) 17 print(f"姓名:{name};总价:{report['calculation']['total']} 元") 18 print(f"两个名字指向同一个列表:{report['shared_list']['same_object']}") 19 print(f"复制前后是同一个列表:{report['copied_list']['same_object']}") 20 return report 21 22@app.post("/chat") 23async def chat(request: ChatRequest) -> dict[str, str]: 24 model_name = os.environ.get("DEEPSEEK_MODEL", "deepseek-v4-flash") 25 api_key = os.environ.get("DEEPSEEK_API_KEY", "xxxx").strip() 26 base_url = os.environ.get("DEEPSEEK_BASE_URL", "https://api.deepseek.com") 27 28 if not api_key or api_key == "xxxx": 29 raise HTTPException( 30 status_code=400, 31 detail="请在 .env 中把 DEEPSEEK_API_KEY=xxxx 替换为自己的密钥,保存后重新运行。", 32 ) 33 34 model = ChatOpenAI(model=model_name, api_key=api_key, base_url=base_url) 35 response = await model.ainvoke(request.question) 36 answer = response.text 37 return {"answer": answer}
name、price 和 quantity 来自查询参数,report 保存 build_report() 的返回值。在 /chat 中,model_name、api_key 和 base_url 保存配置,model 保存模型对象,response 保存返回的消息对象,answer 保存要返回给浏览器的文本。给这些中间结果起清楚的名字,调试时就能直接检查每一步的数据。
price
quantity
report
model_name
api_key
base_url
model
response
answer
request.question 是请求对象的 question 属性,它对应 ChatRequest 定义的字段。response.text 也是属性,用来提取消息中的纯文本。消息的 content 可能是字符串,也可能包含多个内容块,所以这里使用 text,让 answer 与接口声明的字符串类型一致。LangChain 的 BaseMessage.text 文档
request.question
question
ChatRequest
response.text
content
text
BaseMessage.text
本篇在线案例的文件结构如下。我们会先运行不需要密钥的变量接口,再根据需要尝试模型调用。
variables.py 把前面分散的例子放进 build_report()。每次调用都会重新创建实验使用的变量和列表,重复发送请求不会累积上一次的更改。函数返回的字典交给 FastAPI 转换成 JSON,方便我们在响应区域观察结果。
01DEFAULT_TIMEOUT = 30 02 03def build_report(name: str, price: int, quantity: int) -> dict[str, object]: 04 # 重新赋值:原来的字符串保持不变,message 指向新的字符串。 05 message = "欢迎学习 Python" 06 previous_message = message 07 message = f"你好,{name},今天继续学习变量。" 08 09 # 类型属于对象;同一个名字可以先后指向不同类型的对象。 10 value = 18 11 previous_value = value 12 previous_type = type(value).__name__ 13 value = "十八" 14 15 total = price * quantity 16 age = 18 17 try: 18 invalid_message = "年龄:" + age 19 except TypeError as error: 20 mixed_type_error = type(error).__name__ 21 else: 22 mixed_type_error = "" 23 age_message = f"年龄:{age}" 24 25 # 赋值没有复制列表,两个名字共享同一个对象。 26 languages = ["Python"] 27 another_name = languages 28 another_name.append("LangChain") 29 30 # copy() 创建新的外层列表;本例的元素都是不可变字符串。 31 original_languages = ["Python"] 32 copied_languages = original_languages.copy() 33 copied_languages.append("LangChain") 34 35 original_text = "你好" 36 greeting = original_text 37 greeting += f",{name}" 38 39 first_name, last_name = "小", "微" 40 left, right = "左边", "右边" 41 left, right = right, left 42 first, *middle, last = [1, 2, 3, 4] 43 last_login = None 44 45 return { 46 "assignment": {"before": previous_message, "after": message}, 47 "calculation": {"price": price, "quantity": quantity, "total": total}, 48 "dynamic_type": { 49 "before": {"value": previous_value, "type": previous_type}, 50 "after": {"value": value, "type": type(value).__name__}, 51 "is_string": isinstance(value, str), 52 }, 53 "strong_type": { 54 "string_plus_integer": mixed_type_error, 55 "converted_message": age_message, 56 "integer_plus_float": 1 + 1.5, 57 }, 58 "shared_list": { 59 "original": languages, 60 "alias": another_name, 61 "same_object": languages is another_name, 62 }, 63 "copied_list": { 64 "original": original_languages, 65 "copy": copied_languages, 66 "same_object": original_languages is copied_languages, 67 }, 68 "immutable_string": {"original": original_text, "result": greeting}, 69 "unpacking": { 70 "full_name": first_name + last_name, 71 "swapped": {"left": left, "right": right}, 72 "first": first, "middle": middle, "last": last, 73 }, 74 "configuration": { 75 "DEFAULT_TIMEOUT": DEFAULT_TIMEOUT, 76 "last_login": last_login, 77 "has_no_login": last_login is None, 78 }, 79 } 80 81if __name__ == "__main__": 82 import json 83 84 print(json.dumps(build_report("小微", 30, 2), ensure_ascii=False, indent=2))
这里有意执行了一次字符串与整数相加,并在 except TypeError 中记录错误名称。响应里的 "TypeError" 是实验结果,异常已经被捕获,不会中断整个请求。第 2 节的 NameError 是另一段用于理解错误的独立示例,没有放进这个函数。
except TypeError
"TypeError"
打开本篇的在线案例,点击运行,等待运行环境就绪。案例预览默认选择 GET,请求地址是:
GET
1/variables?name=小微&price=30&quantity=2
点击发送后,响应会包含赋值、计算、类型、对象引用、字符串和解包等结果。下面摘出其中几组,便于与代码对应:
01{ 02 "calculation": {"price": 30, "quantity": 2, "total": 60}, 03 "dynamic_type": { 04 "before": {"value": 18, "type": "int"}, 05 "after": {"value": "十八", "type": "str"}, 06 "is_string": true 07 }, 08 "strong_type": { 09 "string_plus_integer": "TypeError", 10 "converted_message": "年龄:18", 11 "integer_plus_float": 2.5 12 }, 13 "shared_list": { 14 "original": ["Python", "LangChain"], 15 "alias": ["Python", "LangChain"], 16 "same_object": true 17 }, 18 "copied_list": { 19 "original": ["Python"], 20 "copy": ["Python", "LangChain"], 21 "same_object": false 22 }, 23 "configuration": { 24 "DEFAULT_TIMEOUT": 30, 25 "last_login": null, 26 "has_no_login": true 27 } 28}
shared_list.same_object 为 true,说明 languages 与 another_name 指向同一个列表;追加内容后,两者看到的都是 Python 和 LangChain。copied_list.same_object 为 false,说明原列表与副本是不同的外层列表,给副本追加内容后,原列表仍然只有 Python。
shared_list.same_object
true
languages
another_name
Python
LangChain
copied_list.same_object
false
same_object 是 Python 的 is 运算计算出来的结果。 JSON 只保存值,不会保留 Python 对象之间的别名关系。我们不能仅凭两个 JSON 数组的内容相同,就认定它们在 Python 中是同一个对象。响应中 None 显示为 null,True 和 False 则分别显示为 true 和 false。
same_object
is
null
日志区域会打印姓名、总价以及两组列表的对象比较结果。随后可以把请求地址改成 /variables?name=小明&price=20&quantity=4,再次发送,观察问候内容和总价如何变化;这次 calculation.total 应当是 80。
/variables?name=小明&price=20&quantity=4
calculation.total
80
如果想改变实验本身,可以在 variables.py 中把 value = 18 改为 value = 20,或者把追加的 LangChain 改为 LangGraph,保存后重新运行。前一种修改会改变 dynamic_type.before.value,后一种会改变列表内容,但赋值共享引用、浅复制创建新外层列表的关系保持不变。也可以把 DEFAULT_TIMEOUT 改成另一个整数,观察 configuration 中的对应结果。
value = 18
value = 20
LangGraph
dynamic_type.before.value
configuration
变量实验无需配置 DeepSeek。如果希望继续观察请求对象、配置变量和模型消息,打开 .env,把最后一行的 xxxx 替换为自己的 DeepSeek API Key,保存后重新运行:
.env
xxxx
1DEEPSEEK_MODEL=deepseek-v4-flash 2DEEPSEEK_BASE_URL=https://api.deepseek.com 3# 仅 POST /chat 需要密钥:请把 xxxx 替换为自己的 DeepSeek API Key。 4# 保存后重新运行;默认 GET /variables 不需要修改本文件。 5DEEPSEEK_API_KEY=xxxx
在案例预览中把请求方法改为 POST,地址改为 /chat,请求体填写:
POST
1{ 2 "question": "请用一句话解释 Python 变量和对象的关系。" 3}
这次请求会真实调用 ChatOpenAI.ainvoke(),响应中的 answer 来自 response.text。保留 xxxx 时,接口返回 HTTP 400 和填写密钥的说明。浏览器模式会直连配置中的模型地址,目标服务需要允许当前网站的跨域请求;真实密钥只填写在自己的 .env 中,不要放进 .env.example 或提交到 Git。
ChatOpenAI.ainvoke()
.env.example
下载项目后,也可以在本机的项目目录执行下面的命令。第一条直接打印变量实验结果,第二条启动 FastAPI,之后访问 /variables 或 /docs:
/variables
/docs
1uv run python variables.py 2uv run --env-file .env fastapi dev main.py
本机使用 .python-version 指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例在浏览器中执行 FastAPI 接口,无需启动本机端口;依赖下载缓存可以与同站文章共享,本篇的文件草稿、运行日志、Git 配置和 PI Agent 对话仍然使用独立的工作区。
.python-version
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 概述
变量是给数据起的名字。我们不必每次都直接面对一段字符串、一个数字或一组列表,而是先给它一个容易理解的名字,后面通过这个名字使用数据。
这里的
name和age就是变量,"小微"和18是它们当前指向的数据。初学时可以先把
name = "小微"读成“让变量name指向字符串"小微"”。等理解了这个关系,就不容易把 Python 变量误解成只能存放一种固定类型的盒子。2. 创建、读取和修改变量
Python 使用等号
=进行赋值。第一次给一个名字赋值时,这个名字就创建出来了;之后再次赋值,就是让它指向新的数据。第二次赋值不会修改原来的字符串,而是让
message改为指向新的字符串。变量名相同,当前指向的数据可以不同。第一次赋值让 message 指向字符串“欢迎学习 Python”。第二次赋值让同一个变量名改为指向“今天继续学习变量”。旧字符串没有被修改;图中上下两行表示赋值前后的两个时刻。
BEFORE / 第一次赋值
AFTER / 再次赋值
message
同一个变量名
“欢迎学习 Python”
不可变字符串对象
message
改变当前指向
“今天继续学习变量”
另一个字符串对象
变量的值可以参与计算、拼接和条件判断:
等号右边先计算,得到结果后再赋给等号左边的变量。因此,
total保存的是price * quantity的计算结果。如果直接读取一个还没有创建的变量,Python 会抛出
NameError:把变量放在使用它的代码之前,是最简单也最可靠的习惯。上面这段代码是单独观察错误的例子,执行时会停止在
NameError;后面的完整服务没有加入这条语句,避免启动时就被中断。3. 语言特性
在一些语言中,创建变量时要先写明它只能保存什么类型。Python 不需要这样做:
类型属于对象。赋值时,变量名与右侧的对象建立关联,同一个名字可以先后指向不同类型的对象。因此,下面的代码是合法的:
这体现了 Python 的动态类型:变量名没有预先固定的类型,程序在运行时根据当前对象处理操作。这里
value从整数对象改为指向字符串对象,原来的整数并没有变成字符串。这样的写法比较灵活,拼写错误或不兼容的操作也往往要到执行时才会暴露。Python 中的操作仍然要遵守类型规则。比如,数字和字符串不能直接相加:
需要先明确转换类型,或者使用 f-string 进行拼接:
Python 的这种表现通常被称为强类型:操作需要满足相应的类型规则,不兼容时会报错。不同类型也可能按明确的规则一起运算,例如
1 + 1.5会得到2.5,因此不能把强类型理解成“不同类型一律不能参与同一个操作”。动态类型描述变量与对象在运行时的关系,强类型描述操作对类型的要求,这两个特点可以同时成立。需要特别注意:变量名保存的是对象引用
在 Python 中,变量更像一个标签,贴在对象上。多个变量可以同时指向同一个对象:
another_name = languages没有复制列表,而是让两个名字指向同一个列表对象。因此通过其中一个名字修改列表,另一个名字看到的内容也会改变。这也是 Python 中“赋值”和“复制”需要区分的原因。如果确实需要一份独立的列表,可以显式复制:
copy()复制的是外层列表,属于浅复制。这个例子中的元素都是不可变字符串,给副本追加内容不会改变原列表;如果元素里还有列表或字典,内层对象仍然可能被两份列表共享。下一篇学习具体数据类型时,我们会继续讨论这些区别。变量名没有固定类型,它当前指向的对象有类型。
type()可以查看对象类型,isinstance()可以判断对象是否属于某个类型:这种设计也支持 Python 常见的鸭子类型思想:函数通常关心对象能做什么,而不是它具体属于哪个类。例如,只要对象支持
len(),就可以传给下面的函数:有些对象创建后不能直接修改自身的值,这类对象叫不可变对象,例如整数、字符串和元组。字符串拼接会得到一个结果字符串,再把变量名与这个结果关联起来,原字符串保持不变:
列表和字典属于常见的可变对象,可以在原对象上修改内容:
理解这一区别很重要:重新给变量赋值,是改变变量名的指向;调用
append()这类方法,是直接修改可变对象本身。4. 命名规则
变量名必须遵守几条语法规则:
name和Name是两个不同的名字;if、for、class和def。除了语法规则,项目还需要统一命名习惯。Python 社区通常使用
snake_case命名变量和函数,使用大写字母加下划线表示希望保持不变的常量:DEFAULT_TIMEOUT只是命名约定,Python 不会阻止别人重新给它赋值。大写名称的作用是提醒协作者:这个值在程序运行期间最好不要修改。5. 常见的数据类型
变量可以指向各种对象,最常见的类型包括:
int18float3.14str"Python"boolTrue、FalseNoneTypeNonelist["Python", "FastAPI"]tuple("Python", "FastAPI")dict{"name": "小微"}元组的不可变指的是其中各个位置保存的对象引用不能替换。元组也可以包含列表,这个列表内部的内容仍然可以改变;元组本身不可变,并不保证它包含的所有对象都不可变。
None不是字符串,也不是数字。它通常用来表示“还没有结果”“暂时未知”或“这里有意留空”。判断它时,推荐使用is None:6. 多个变量一起赋值
Python 支持在一行中给多个变量赋值:
等号右侧的内容会按照顺序交给左侧的变量。这种写法叫解包;这里处理的是序列,可迭代对象也支持解包。它还可以用来交换两个变量的值:
如果左右数量对不上,Python 会提示解包数量错误。需要接收剩余内容时,可以使用带星号的变量:
7. 在 FastAPI 和 LangChain 中使用变量
上一篇学习了模块拆分,这一篇继续用两个 Python 文件组织案例:
variables.py保存变量实验,main.py导入其中的build_report(),负责提供接口。默认的
GET /variables会返回实验结果,不需要模型密钥。可选的POST /chat则通过变量读取模型配置、保存请求内容和模型回复。模型对象在收到/chat请求后才创建;没有填写密钥时,这个接口会返回配置说明,变量实验仍然可以运行。name、price和quantity来自查询参数,report保存build_report()的返回值。在/chat中,model_name、api_key和base_url保存配置,model保存模型对象,response保存返回的消息对象,answer保存要返回给浏览器的文本。给这些中间结果起清楚的名字,调试时就能直接检查每一步的数据。request.question是请求对象的question属性,它对应ChatRequest定义的字段。response.text也是属性,用来提取消息中的纯文本。消息的content可能是字符串,也可能包含多个内容块,所以这里使用text,让answer与接口声明的字符串类型一致。LangChain 的BaseMessage.text文档8. 在线变量实验
本篇在线案例的文件结构如下。我们会先运行不需要密钥的变量接口,再根据需要尝试模型调用。
8.1 变量实验代码
variables.py把前面分散的例子放进build_report()。每次调用都会重新创建实验使用的变量和列表,重复发送请求不会累积上一次的更改。函数返回的字典交给 FastAPI 转换成 JSON,方便我们在响应区域观察结果。这里有意执行了一次字符串与整数相加,并在
except TypeError中记录错误名称。响应里的"TypeError"是实验结果,异常已经被捕获,不会中断整个请求。第 2 节的NameError是另一段用于理解错误的独立示例,没有放进这个函数。8.2 运行并观察结果
打开本篇的在线案例,点击运行,等待运行环境就绪。案例预览默认选择
GET,请求地址是:点击发送后,响应会包含赋值、计算、类型、对象引用、字符串和解包等结果。下面摘出其中几组,便于与代码对应:
shared_list.same_object为true,说明languages与another_name指向同一个列表;追加内容后,两者看到的都是Python和LangChain。copied_list.same_object为false,说明原列表与副本是不同的外层列表,给副本追加内容后,原列表仍然只有Python。same_object是 Python 的is运算计算出来的结果。 JSON 只保存值,不会保留 Python 对象之间的别名关系。我们不能仅凭两个 JSON 数组的内容相同,就认定它们在 Python 中是同一个对象。响应中None显示为null,True和False则分别显示为true和false。日志区域会打印姓名、总价以及两组列表的对象比较结果。随后可以把请求地址改成
/variables?name=小明&price=20&quantity=4,再次发送,观察问候内容和总价如何变化;这次calculation.total应当是80。如果想改变实验本身,可以在
variables.py中把value = 18改为value = 20,或者把追加的LangChain改为LangGraph,保存后重新运行。前一种修改会改变dynamic_type.before.value,后一种会改变列表内容,但赋值共享引用、浅复制创建新外层列表的关系保持不变。也可以把DEFAULT_TIMEOUT改成另一个整数,观察configuration中的对应结果。8.3 可选的模型调用
变量实验无需配置 DeepSeek。如果希望继续观察请求对象、配置变量和模型消息,打开
.env,把最后一行的xxxx替换为自己的 DeepSeek API Key,保存后重新运行:在案例预览中把请求方法改为
POST,地址改为/chat,请求体填写:这次请求会真实调用
ChatOpenAI.ainvoke(),响应中的answer来自response.text。保留xxxx时,接口返回 HTTP 400 和填写密钥的说明。浏览器模式会直连配置中的模型地址,目标服务需要允许当前网站的跨域请求;真实密钥只填写在自己的.env中,不要放进.env.example或提交到 Git。下载项目后,也可以在本机的项目目录执行下面的命令。第一条直接打印变量实验结果,第二条启动 FastAPI,之后访问
/variables或/docs:本机使用
.python-version指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例在浏览器中执行 FastAPI 接口,无需启动本机端口;依赖下载缓存可以与同站文章共享,本篇的文件草稿、运行日志、Git 配置和 PI Agent 对话仍然使用独立的工作区。