函数是一段可以重复调用的代码。把一组有明确职责的操作放进函数后,其他地方只需要调用函数名,不必重复编写内部细节。
使用 def 定义函数,函数体通过缩进表示:
def
1def say_hello(): 2 print("你好,Python") 3 4say_hello()
def say_hello(): 只是创建函数,下面的 say_hello() 才是真正调用它。调用时必须保留括号,即使函数没有参数也一样。
def say_hello():
say_hello()
函数可以接收参数,让同一段逻辑处理不同的数据:
1def greet(name): 2 print(f"你好,{name}") 3 4greet("小明") 5greet("小红")
函数名应该表达动作或结果,例如 calculate_total()、load_user()、format_message()。一个函数最好只负责一类事情,函数太长或同时做很多不相关的事情时,可以继续拆分。
calculate_total()
load_user()
format_message()
可以使用文档字符串说明函数用途,方便自己和其他人阅读:
1def add(left, right): 2 """返回两个数字的和。""" 3 return left + right 4 5print(add.__doc__)
参数写在函数定义的括号中,调用时传入的值叫作实参:
1def introduce(name, age): 2 print(f"{name} 今年 {age} 岁") 3 4introduce("小明", 18)
上面的 name 和 age 是参数,"小明" 和 18 是实参。默认情况下,Python 按照位置把实参依次传给参数。
name
age
"小明"
18
可以为参数设置默认值。调用时不传这个参数,就使用默认值:
1def greet(name, greeting="你好"): 2 print(f"{greeting},{name}") 3 4greet("小明") 5greet("小红", "早上好")
对于普通位置参数,有默认值的参数必须放在没有默认值的参数后面。后面介绍的仅限关键字参数不受这个顺序限制:
1def connect(host, port=8000): 2 print(f"连接 {host}:{port}") 3 4connect("localhost") 5connect("localhost", 9000)
不要把列表、字典等可变对象直接作为默认值。默认值只会在函数定义时创建一次,多次调用可能会共享同一个对象:
1def add_topic(topic, topics=None): 2 if topics is None: 3 topics = [] 4 5 topics.append(topic) 6 return topics 7 8print(add_topic("变量")) 9print(add_topic("列表"))
使用 None 作为默认值,再在函数内部创建新列表,是更安全的写法。
None
函数可以使用 return 把结果交给调用方:
return
1def add(left, right): 2 return left + right 3 4result = add(2, 3) 5print(result) # 5
return 会立即结束当前函数。它后面的代码不会继续执行:
1def check_age(age): 2 if age < 18: 3 return "未成年" 4 5 return "已成年" 6 7print(check_age(16))
如果函数没有写 return,或者只写了没有返回值的 return,函数结果就是 None:
1def print_message(message): 2 print(message) 3 4result = print_message("处理完成") 5print(result) # None
函数可以返回多个值。Python 会把它们组合成一个元组,调用方可以直接解包:
1def calculate(numbers): 2 total = sum(numbers) 3 count = len(numbers) 4 return total, total / count 5 6total, average = calculate([80, 90, 70]) 7print(total) # 240 8print(average) # 80.0
函数应该返回结果,而不是只依赖 print() 输出。print() 适合展示信息,return 才能让调用方继续使用这个值:
print()
1def wrong_add(left, right): 2 print(left + right) 3 4def correct_add(left, right): 5 return left + right 6 7wrong_result = wrong_add(1, 2) # 打印 3,但结果是 None 8correct_result = correct_add(1, 2) # 结果是 3 9print(correct_result)
调用函数时,可以按位置传参,也可以按参数名传参。关键字参数更容易表达每个值的含义:
1def create_user(name, age, city): 2 return {"name": name, "age": age, "city": city} 3 4user = create_user(age=18, city="上海", name="小明") 5print(user)
位置参数必须放在关键字参数前面,关键字参数之间的顺序可以调整:
1def connect(host, port, timeout=30): 2 print(host, port, timeout) 3 4connect("localhost", port=8000, timeout=10)
在参数前加 *,可以把多个位置参数收集成一个元组:
*
1def total(*numbers): 2 return sum(numbers) 3 4print(total(1, 2, 3)) 5print(total(10, 20, 30, 40))
在参数前加 **,可以把多个关键字参数收集成一个字典:
**
1def show_options(**options): 2 for key, value in options.items(): 3 print(f"{key}:{value}") 4 5show_options(model="deepseek-chat", temperature=0.2)
如果希望某些参数只能使用关键字传入,可以在它们前面使用单独的 *:
1def request(path, *, timeout=30): 2 print(path, timeout) 3 4request("/users", timeout=10) 5# request("/users", 10) # TypeError
*args、**kwargs 很灵活,但会降低函数签名的清晰度。只有确实需要接收不定数量参数时再使用它们,普通函数优先写出明确的参数名。
*args
**kwargs
函数内部创建的变量通常是局部变量,只能在函数内部使用:
1def calculate(): 2 result = 2 + 3 3 return result 4 5print(calculate()) 6# print(result) # NameError
函数外部的变量属于外部作用域。函数可以读取外部变量,但如果要在函数内部修改外部变量,最好通过参数和返回值传递,而不是依赖全局变量:
1default_timeout = 30 2 3def get_timeout(): 4 return default_timeout 5 6print(get_timeout())
参数和局部变量可以遮蔽同名的外部变量:
1name = "外部名字" 2 3def show_name(name): 4 print(name) 5 6show_name("函数参数") 7print(name) # 外部名字
类型提示可以写在参数和返回值旁边,帮助编辑器提示和读者理解数据类型。它不会自动阻止错误类型传入,运行时校验仍然需要 Pydantic 等工具:
1def add(left: int, right: int) -> int: 2 return left + right 3 4print(add(2, 3))
函数可以组合使用,一个函数调用另一个函数。把清理、校验和组装分别放进小函数,代码更容易测试和复用:
01def clean_question(question: str) -> str: 02 return question.strip() 03 04def is_valid_question(question: str) -> bool: 05 return len(question) > 0 06 07def prepare_question(question: str) -> str | None: 08 cleaned = clean_question(question) 09 10 if not is_valid_question(cleaned): 11 return None 12 13 return cleaned 14 15print(prepare_question(" 介绍一下 Python ")) 16print(prepare_question(" "))
在 FastAPI 和 LangChain 项目中,可以把请求数据组装为独立函数:
01def build_chat_request(question: str, model: str = "deepseek-chat") -> dict: 02 return { 03 "model": model, 04 "messages": [ 05 {"role": "user", "content": question}, 06 ], 07 } 08 09request = build_chat_request("请介绍一下 Python。") 10print(request)
这样,接口入口只需要接收请求并调用 build_chat_request(),模型名称和消息结构的组装逻辑集中在一个地方。以后更换模型字段或增加参数时,只需要修改这个函数。
build_chat_request()
函数也可以接收另一个函数作为参数。Python 中函数也是对象,因此可以把行为传给通用函数:
1def apply_twice(value, action): 2 return action(action(value)) 3 4def add_exclamation(text): 5 return text + "!" 6 7print(apply_twice("你好", add_exclamation)) # 你好!!
初学时不必急着大量使用高阶函数,但理解「函数可以被传递」后,会更容易读懂排序、异步回调和 LangChain 链式组合中的代码。
本篇把前面的知识放进一个可修改的 Python 项目。main.py 只负责接收参数并调用实验函数,functions_demo.py 保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。
main.py
functions_demo.py
01def greet(name: str, greeting: str = "你好") -> str: 02 return f"{greeting},{name}" 03 04def add(left: int, right: int) -> int: 05 """返回两个数字的和。""" 06 return left + right 07 08def print_message(message: str) -> None: 09 print(message) 10 11def calculate(numbers: list[int]) -> tuple[int, float | None]: 12 total = sum(numbers) 13 if not numbers: 14 return total, None 15 return total, total / len(numbers) 16 17def add_topic(topic: str, topics: list[str] | None = None) -> list[str]: 18 if topics is None: 19 topics = [] 20 topics.append(topic) 21 return topics 22 23def total(*numbers: int) -> int: 24 return sum(numbers) 25 26def make_options(**options: object) -> dict[str, object]: 27 return options 28 29def request_options(path: str, *, timeout: int = 30) -> dict[str, object]: 30 return {"path": path, "timeout": timeout} 31 32def clean_question(question: str) -> str: 33 return question.strip() 34 35def is_valid_question(question: str) -> bool: 36 return len(question) > 0 37 38def prepare_question(question: str) -> str | None: 39 cleaned = clean_question(question) 40 if not is_valid_question(cleaned): 41 return None 42 return cleaned 43 44def build_chat_request(question: str, model: str = "example-model") -> dict[str, object]: 45 # 这里只组装数据,不发起模型请求。 46 return {"model": model, "messages": [{"role": "user", "content": question}]} 47 48def apply_twice(value: str, action) -> str: 49 return action(action(value)) 50 51def add_exclamation(text: str) -> str: 52 return text + "!" 53 54def build_report(name: str, left: int, right: int, question: str) -> dict[str, object]: 55 sum_value, average = calculate([left, right]) 56 cleaned = prepare_question(question) 57 first_topics = add_topic("变量") 58 second_topics = add_topic("函数") 59 return { 60 "parameters": { 61 "positional": greet(name), 62 "keyword": greet(greeting="早上好", name=name), 63 "default_greeting": greet(name), 64 }, 65 "return_values": { 66 "add": add(left, right), 67 "printed_result": print_message("这条内容在日志中,函数返回 None"), 68 "unpacked": {"total": sum_value, "average": average}, 69 "empty_numbers": calculate([]), 70 }, 71 "mutable_defaults": { 72 "first": first_topics, 73 "second": second_topics, 74 "same_object": first_topics is second_topics, 75 }, 76 "flexible_arguments": { 77 "args_total": total(left, right, 10), 78 "kwargs": make_options(model="example-model", temperature=0.2), 79 "keyword_only": request_options("/users", timeout=10), 80 }, 81 "composition": { 82 "original": question, 83 "cleaned": cleaned, 84 "request": build_chat_request(cleaned) if cleaned is not None else None, 85 "callback": apply_twice(name, add_exclamation), 86 }, 87 "docstring": add.__doc__, 88 } 89
01from fastapi import FastAPI, Query 02 03from functions_demo import build_report 04 05app = FastAPI() 06 07@app.get("/functions") 08async def functions( 09 name: str = Query("小微", min_length=1, max_length=80), 10 left: int = Query(2, ge=-1000, le=1000), 11 right: int = Query(3, ge=-1000, le=1000), 12 question: str = Query("介绍一下 Python", max_length=500), 13) -> dict[str, object]: 14 return build_report(name, left, right, question) 15
01[project] 02name = "python-functions" 03version = "0.1.0" 04description = "Python 函数" 05readme = "README.md" 06requires-python = ">=3.12" 07dependencies = [ 08 "fastapi[standard]==0.136.1; sys_platform != 'emscripten'", 09 "fastapi==0.136.1; sys_platform == 'emscripten'", 10 "pydantic==2.12.5", 11 "httpx==0.28.1", 12] 13 14[tool.uv] 15package = false 16
其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回 422。
422
打开在线案例,点击运行,等待环境就绪。案例预览默认使用 GET,地址是:
GET
1/functions?name=小微&left=2&right=3&question=介绍一下Python
默认参数得到 return_values.add = 5,元组解包后的 total = 5、average = 2.5。printed_result 是 null,对应 Python 的 None;实际打印的文字出现在日志里。两个默认列表分别是 ["变量"] 和 ["函数"],same_object 为 false。
return_values.add = 5
total = 5
average = 2.5
printed_result
null
["变量"]
["函数"]
same_object
false
把 question 改成只含空格的查询值,例如 /functions?question=%20%20,composition.cleaned 与 composition.request 都会变成 null。calculate([]) 也会返回总和 0 和空平均值,避免空列表除以零。JSON 会把 Python 元组展示成数组。
question
/functions?question=%20%20
composition.cleaned
composition.request
calculate([])
0
可以修改 functions_demo.py 的问候默认值、add() 的计算规则或 prepare_question() 的校验条件,保存并重新运行。build_chat_request() 只演示数据组装,example-model 是普通字符串,不会调用模型。
add()
prepare_question()
example-model
下载 ZIP 并解压,在项目目录执行:
1uv run fastapi dev main.py
然后打开 http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。
http://127.0.0.1:8000/docs
本机使用 .python-version 指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。
.python-version
此段落已有评论,按 Enter 查看评论及回复列表。
连接 GitHub 后查看和发表评论,也可在 GitHub 查看公开讨论。
1. 定义
函数是一段可以重复调用的代码。把一组有明确职责的操作放进函数后,其他地方只需要调用函数名,不必重复编写内部细节。
使用
def定义函数,函数体通过缩进表示:def say_hello():只是创建函数,下面的say_hello()才是真正调用它。调用时必须保留括号,即使函数没有参数也一样。函数可以接收参数,让同一段逻辑处理不同的数据:
函数名应该表达动作或结果,例如
calculate_total()、load_user()、format_message()。一个函数最好只负责一类事情,函数太长或同时做很多不相关的事情时,可以继续拆分。可以使用文档字符串说明函数用途,方便自己和其他人阅读:
2. 参数
参数写在函数定义的括号中,调用时传入的值叫作实参:
上面的
name和age是参数,"小明"和18是实参。默认情况下,Python 按照位置把实参依次传给参数。可以为参数设置默认值。调用时不传这个参数,就使用默认值:
对于普通位置参数,有默认值的参数必须放在没有默认值的参数后面。后面介绍的仅限关键字参数不受这个顺序限制:
不要把列表、字典等可变对象直接作为默认值。默认值只会在函数定义时创建一次,多次调用可能会共享同一个对象:
使用
None作为默认值,再在函数内部创建新列表,是更安全的写法。3. 返回
函数可以使用
return把结果交给调用方:return会立即结束当前函数。它后面的代码不会继续执行:如果函数没有写
return,或者只写了没有返回值的return,函数结果就是None:函数可以返回多个值。Python 会把它们组合成一个元组,调用方可以直接解包:
函数应该返回结果,而不是只依赖
print()输出。print()适合展示信息,return才能让调用方继续使用这个值:4. 调用
调用函数时,可以按位置传参,也可以按参数名传参。关键字参数更容易表达每个值的含义:
位置参数必须放在关键字参数前面,关键字参数之间的顺序可以调整:
在参数前加
*,可以把多个位置参数收集成一个元组:在参数前加
**,可以把多个关键字参数收集成一个字典:如果希望某些参数只能使用关键字传入,可以在它们前面使用单独的
*:*args、**kwargs很灵活,但会降低函数签名的清晰度。只有确实需要接收不定数量参数时再使用它们,普通函数优先写出明确的参数名。5. 作用域
函数内部创建的变量通常是局部变量,只能在函数内部使用:
函数外部的变量属于外部作用域。函数可以读取外部变量,但如果要在函数内部修改外部变量,最好通过参数和返回值传递,而不是依赖全局变量:
参数和局部变量可以遮蔽同名的外部变量:
类型提示可以写在参数和返回值旁边,帮助编辑器提示和读者理解数据类型。它不会自动阻止错误类型传入,运行时校验仍然需要 Pydantic 等工具:
6. 组合
函数可以组合使用,一个函数调用另一个函数。把清理、校验和组装分别放进小函数,代码更容易测试和复用:
在 FastAPI 和 LangChain 项目中,可以把请求数据组装为独立函数:
这样,接口入口只需要接收请求并调用
build_chat_request(),模型名称和消息结构的组装逻辑集中在一个地方。以后更换模型字段或增加参数时,只需要修改这个函数。函数也可以接收另一个函数作为参数。Python 中函数也是对象,因此可以把行为传给通用函数:
初学时不必急着大量使用高阶函数,但理解「函数可以被传递」后,会更容易读懂排序、异步回调和 LangChain 链式组合中的代码。
7. 在线函数实验
本篇把前面的知识放进一个可修改的 Python 项目。
main.py只负责接收参数并调用实验函数,functions_demo.py保存本篇的逻辑。默认接口不需要密钥,也不会调用外部模型。7.1 完整实验代码
7.2 接口与配置
其余配置文件可在在线案例左侧的文件目录中查看,也会包含在下载包里。接口的输入有明确的长度、数量或数值范围,超出范围时 FastAPI 会返回
422。7.3 运行和观察
打开在线案例,点击运行,等待环境就绪。案例预览默认使用
GET,地址是:默认参数得到
return_values.add = 5,元组解包后的total = 5、average = 2.5。printed_result是null,对应 Python 的None;实际打印的文字出现在日志里。两个默认列表分别是["变量"]和["函数"],same_object为false。把
question改成只含空格的查询值,例如/functions?question=%20%20,composition.cleaned与composition.request都会变成null。calculate([])也会返回总和0和空平均值,避免空列表除以零。JSON 会把 Python 元组展示成数组。可以修改
functions_demo.py的问候默认值、add()的计算规则或prepare_question()的校验条件,保存并重新运行。build_chat_request()只演示数据组装,example-model是普通字符串,不会调用模型。7.4 本机运行
下载 ZIP 并解压,在项目目录执行:
然后打开
http://127.0.0.1:8000/docs,选择对应接口,填写和在线案例相同的参数发送请求。本机使用
.python-version指定的 Python 3.12,浏览器使用当前 Pyodide 的 Python 版本。在线案例通过 ASGITransport 执行 FastAPI,不监听本机端口,无需安装本机 Python。每次请求都会新建本次实验的状态,本篇的代码草稿、Git、日志和 Agent 对话也与其他文章分开保存。