跳到主内容

LangChain Python

最后更新: 2026-10-11

1. 概述

变量是给数据起的名字。我们不必每次都直接面对一段字符串、一个数字或一组列表,而是先给它一个容易理解的名字,后面通过这个名字使用数据。

main.py
1
name = "小微"
2
age = 18
3
4
print(name)
5
print(age)

这里的 name 和 age 就是变量,"小微" 和 18 是它们当前指向的数据。

初学时可以先把 name = "小微" 读成“让变量 name 指向字符串 "小微"”。等理解了这个关系,就不容易把 Python 变量误解成只能存放一种固定类型的盒子。

2. 创建、读取和修改变量

Python 使用等号 = 进行赋值。第一次给一个名字赋值时,这个名字就创建出来了;之后再次赋值,就是让它指向新的数据。

main.py
1
message = "欢迎学习 Python"
2
print(message)
3
4
message = "今天继续学习变量"
5
print(message)

第二次赋值不会修改原来的字符串,而是让 message 改为指向新的字符串。变量名相同,当前指向的数据可以不同。

Python 变量 / 重新绑定

第一次赋值让 message 指向字符串“欢迎学习 Python”。第二次赋值让同一个变量名改为指向“今天继续学习变量”。旧字符串没有被修改;图中上下两行表示赋值前后的两个时刻。

变量的值可以参与计算、拼接和条件判断:

main.py
1
price = 30
2
quantity = 2
3
total = price * quantity
4
5
print(f"总价是 {total} 元")

等号右边先计算,得到结果后再赋给等号左边的变量。因此,total 保存的是 price * quantity 的计算结果。

如果直接读取一个还没有创建的变量,Python 会抛出 NameError:

main.py
1
print(username) # NameError:username 还没有定义

把变量放在使用它的代码之前,是最简单也最可靠的习惯。上面这段代码是单独观察错误的例子,执行时会停止在 NameError;后面的完整服务没有加入这条语句,避免启动时就被中断。

3. 语言特性

在一些语言中,创建变量时要先写明它只能保存什么类型。Python 不需要这样做:

main.py
1
score = 100
2
name = "小微"
3
enabled = True

类型属于对象。赋值时,变量名与右侧的对象建立关联,同一个名字可以先后指向不同类型的对象。因此,下面的代码是合法的:

main.py
1
value = 18
2
print(type(value))
3
4
value = "十八"
5
print(type(value))

这体现了 Python 的动态类型:变量名没有预先固定的类型,程序在运行时根据当前对象处理操作。这里 value 从整数对象改为指向字符串对象,原来的整数并没有变成字符串。这样的写法比较灵活,拼写错误或不兼容的操作也往往要到执行时才会暴露。

Python 中的操作仍然要遵守类型规则。比如,数字和字符串不能直接相加:

main.py
1
age = 18
2
message = "年龄:" + age # TypeError

需要先明确转换类型,或者使用 f-string 进行拼接:

main.py
1
age = 18
2
3
message = "年龄:" + str(age)
4
print(message)
5
6
print(f"年龄:{age}")

Python 的这种表现通常被称为强类型:操作需要满足相应的类型规则,不兼容时会报错。不同类型也可能按明确的规则一起运算,例如 1 + 1.5 会得到 2.5,因此不能把强类型理解成“不同类型一律不能参与同一个操作”。动态类型描述变量与对象在运行时的关系,强类型描述操作对类型的要求,这两个特点可以同时成立。

需要特别注意:变量名保存的是对象引用

在 Python 中,变量更像一个标签,贴在对象上。多个变量可以同时指向同一个对象:

main.py
1
languages = ["Python"]
2
another_name = languages
3
4
another_name.append("LangChain")
5
print(languages) # ['Python', 'LangChain']

another_name = languages 没有复制列表,而是让两个名字指向同一个列表对象。因此通过其中一个名字修改列表,另一个名字看到的内容也会改变。

这也是 Python 中“赋值”和“复制”需要区分的原因。如果确实需要一份独立的列表,可以显式复制:

main.py
1
languages = ["Python"]
2
another_name = languages.copy()
3
4
another_name.append("LangChain")
5
print(languages) # ['Python']
6
print(another_name) # ['Python', 'LangChain']

copy() 复制的是外层列表,属于浅复制。这个例子中的元素都是不可变字符串,给副本追加内容不会改变原列表;如果元素里还有列表或字典,内层对象仍然可能被两份列表共享。下一篇学习具体数据类型时,我们会继续讨论这些区别。

变量名没有固定类型,它当前指向的对象有类型。type() 可以查看对象类型,isinstance() 可以判断对象是否属于某个类型:

main.py
1
value = 18
2
3
print(type(value))
4
print(isinstance(value, int))
5
print(isinstance(value, str))

这种设计也支持 Python 常见的鸭子类型思想:函数通常关心对象能做什么,而不是它具体属于哪个类。例如,只要对象支持 len(),就可以传给下面的函数:

main.py
1
def show_length(value):
2
return len(value)
3
4
print(show_length("Python"))
5
print(show_length(["FastAPI", "LangChain"]))

有些对象创建后不能直接修改自身的值,这类对象叫不可变对象,例如整数、字符串和元组。字符串拼接会得到一个结果字符串,再把变量名与这个结果关联起来,原字符串保持不变:

main.py
1
message = "你好"
2
message += ",小微"
3
print(message)

列表和字典属于常见的可变对象,可以在原对象上修改内容:

main.py
1
tasks = ["阅读"]
2
tasks.append("写代码")
3
print(tasks) # ['阅读', '写代码']

理解这一区别很重要:重新给变量赋值,是改变变量名的指向;调用 append() 这类方法,是直接修改可变对象本身。

4. 命名规则

变量名必须遵守几条语法规则:

  • 只能包含字母、数字和下划线,不能包含空格和连字符;
  • 不能以数字开头;
  • 区分大小写,name 和 Name 是两个不同的名字;
  • 不能使用 Python 的关键字,例如 if、for、class 和 def。
main.py
1
user_name = "小微" # 推荐:使用下划线分隔单词
2
user2 = "小明" # 可以:数字不能放在开头
3
4
# 2users = "错误" # 错误:不能以数字开头
5
# user-name = "错误" # 错误:连字符会被解释为减号

除了语法规则,项目还需要统一命名习惯。Python 社区通常使用 snake_case 命名变量和函数,使用大写字母加下划线表示希望保持不变的常量:

main.py
1
DEFAULT_TIMEOUT = 30
2
user_name = "小微"
3
4
def build_message(user_name: str) -> str:
5
return f"你好,{user_name}!"

DEFAULT_TIMEOUT 只是命名约定,Python 不会阻止别人重新给它赋值。大写名称的作用是提醒协作者:这个值在程序运行期间最好不要修改。

5. 常见的数据类型

变量可以指向各种对象,最常见的类型包括:

类型示例用途
int18整数
float3.14小数
str"Python"文本
boolTrue、False是或否
NoneTypeNone表示“目前没有值”
list["Python", "FastAPI"]有顺序、可修改的一组数据
tuple("Python", "FastAPI")有顺序,元素的位置和引用不可修改
dict{"name": "小微"}用键查找值

元组的不可变指的是其中各个位置保存的对象引用不能替换。元组也可以包含列表,这个列表内部的内容仍然可以改变;元组本身不可变,并不保证它包含的所有对象都不可变。

main.py
1
name = "小微"
2
skills = ["Python", "FastAPI"]
3
profile = {"name": name, "skills": skills}
4
last_login = None
5
6
print(profile["name"])
7
print(last_login)

None 不是字符串,也不是数字。它通常用来表示“还没有结果”“暂时未知”或“这里有意留空”。判断它时,推荐使用 is None:

main.py
1
if last_login is None:
2
print("用户还没有登录记录")

6. 多个变量一起赋值

Python 支持在一行中给多个变量赋值:

main.py
1
first_name, last_name = "小", "微"
2
print(first_name, last_name)

等号右侧的内容会按照顺序交给左侧的变量。这种写法叫解包;这里处理的是序列,可迭代对象也支持解包。它还可以用来交换两个变量的值:

main.py
1
left = "左边"
2
right = "右边"
3
4
left, right = right, left
5
print(left) # 右边
6
print(right) # 左边

如果左右数量对不上,Python 会提示解包数量错误。需要接收剩余内容时,可以使用带星号的变量:

main.py
1
first, *middle, last = [1, 2, 3, 4]
2
print(first) # 1
3
print(middle) # [2, 3]
4
print(last) # 4

7. 在 FastAPI 和 LangChain 中使用变量

上一篇学习了模块拆分,这一篇继续用两个 Python 文件组织案例:variables.py 保存变量实验,main.py 导入其中的 build_report(),负责提供接口。

默认的 GET /variables 会返回实验结果,不需要模型密钥。可选的 POST /chat 则通过变量读取模型配置、保存请求内容和模型回复。模型对象在收到 /chat 请求后才创建;没有填写密钥时,这个接口会返回配置说明,变量实验仍然可以运行。

main.py
01
import os
02
03
from fastapi import FastAPI, HTTPException
04
from pydantic import BaseModel
05
from langchain_openai import ChatOpenAI
06
07
from variables import build_report
08
09
app = FastAPI()
10
11
class ChatRequest(BaseModel):
12
question: str
13
14
@app.get("/variables")
15
async 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")
23
async 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 保存要返回给浏览器的文本。给这些中间结果起清楚的名字,调试时就能直接检查每一步的数据。

request.question 是请求对象的 question 属性,它对应 ChatRequest 定义的字段。response.text 也是属性,用来提取消息中的纯文本。消息的 content 可能是字符串,也可能包含多个内容块,所以这里使用 text,让 answer 与接口声明的字符串类型一致。LangChain 的 BaseMessage.text 文档

8. 在线变量实验

本篇在线案例的文件结构如下。我们会先运行不需要密钥的变量接口,再根据需要尝试模型调用。

目录结构
使用上下方向键浏览目录,左右方向键展开或收起,Enter 或空格切换展开状态。
    • main.pyFastAPI 接口与可选模型调用
    • variables.py赋值、对象引用和类型实验
    • .env填写自己的模型密钥
    • .env.example保留 xxxx 的配置模板
    • pyproject.toml项目元信息与依赖
    • .python-version本机使用的 Python 版本
    • .gitignore排除密钥与生成文件
    • README.md运行步骤与实验说明

8.1 变量实验代码

variables.py 把前面分散的例子放进 build_report()。每次调用都会重新创建实验使用的变量和列表,重复发送请求不会累积上一次的更改。函数返回的字典交给 FastAPI 转换成 JSON,方便我们在响应区域观察结果。

variables.py
01
DEFAULT_TIMEOUT = 30
02
03
def 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
81
if __name__ == "__main__":
82
import json
83
84
print(json.dumps(build_report("小微", 30, 2), ensure_ascii=False, indent=2))

这里有意执行了一次字符串与整数相加,并在 except TypeError 中记录错误名称。响应里的 "TypeError" 是实验结果,异常已经被捕获,不会中断整个请求。第 2 节的 NameError 是另一段用于理解错误的独立示例,没有放进这个函数。

8.2 运行并观察结果

打开本篇的在线案例,点击运行,等待运行环境就绪。案例预览默认选择 GET,请求地址是:

code.ts
1
/variables?name=小微&price=30&quantity=2

点击发送后,响应会包含赋值、计算、类型、对象引用、字符串和解包等结果。下面摘出其中几组,便于与代码对应:

code.ts
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。

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,保存后重新运行:

.env
1
DEEPSEEK_MODEL=deepseek-v4-flash
2
DEEPSEEK_BASE_URL=https://api.deepseek.com
3
# 仅 POST /chat 需要密钥:请把 xxxx 替换为自己的 DeepSeek API Key。
4
# 保存后重新运行;默认 GET /variables 不需要修改本文件。
5
DEEPSEEK_API_KEY=xxxx

在案例预览中把请求方法改为 POST,地址改为 /chat,请求体填写:

code.ts
1
{
2
"question": "请用一句话解释 Python 变量和对象的关系。"
3
}

这次请求会真实调用 ChatOpenAI.ainvoke(),响应中的 answer 来自 response.text。保留 xxxx 时,接口返回 HTTP 400 和填写密钥的说明。浏览器模式会直连配置中的模型地址,目标服务需要允许当前网站的跨域请求;真实密钥只填写在自己的 .env 中,不要放进 .env.example 或提交到 Git。

下载项目后,也可以在本机的项目目录执行下面的命令。第一条直接打印变量实验结果,第二条启动 FastAPI,之后访问 /variables 或 /docs:

code.ts
1
uv run python variables.py
2
uv run --env-file .env fastapi dev main.py

本机使用 .python-version 指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例在浏览器中执行 FastAPI 接口,无需启动本机端口;依赖下载缓存可以与同站文章共享,本篇的文件草稿、运行日志、Git 配置和 PI Agent 对话仍然使用独立的工作区。

正在验证登录状态
请稍候,验证完成后将继续显示文章内容

此段落已有评论,按 Enter 查看评论及回复列表。

评论-

文章反应
评论与回复

连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。

添加评论
    即时渲染