Python函数
约 1322 字大约 4 分钟
2026-08-13
函数是可复用的代码块，用于封装特定功能。通过定义函数，可以避免重复代码，提高程序的可读性和可维护性。
定义函数
使用 def 关键字定义函数：
# 定义一个简单函数
def greet():
print("Hello, World!")
# 调用函数
greet() # Hello, World!参数
位置参数
按照定义时的顺序传递参数：
def add(a, b):
return a + b
result = add(3, 5)
print(result) # 8默认参数
为参数指定默认值，调用时可省略：
def greet(name, greeting="Hello"):
print(f"{greeting}, {name}!")
greet("Alice") # Hello, Alice!
greet("Bob", "Hi") # Hi, Bob!注意： 默认参数必须放在非默认参数后面。
# 错误示例
# def greet(greeting="Hello", name): # SyntaxError!
# pass关键字参数
通过参数名传递，顺序可以任意：
def person_info(name, age, city):
print(f"{name}, {age}岁, 来自{city}")
# 关键字参数，顺序无关
person_info(age=25, city="北京", name="Alice")
# Alice, 25岁, 来自北京混合使用： 位置参数在前，关键字参数在后。
person_info("Alice", age=25, city="北京") # 正确
# person_info(name="Alice", 25, "北京") # 错误！位置参数不能在关键字参数后可变参数
*args —— 接收任意数量的位置参数
def sum_all(*args):
total = 0
for num in args:
total += num
return total
# 调用
print(sum_all(1, 2, 3)) # 6
print(sum_all(1, 2, 3, 4)) # 10
print(sum_all()) # 0args 的本质： 函数内部是一个元组。
def show_args(*args):
print(type(args)) # <class 'tuple'>
print(args) # (1, 2, 3)
show_args(1, 2, 3)**kwargs —— 接收任意数量的关键字参数
def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
# 调用
print_info(name="Alice", age=25, city="北京")
# name: Alice
# age: 25
# city: 北京kwargs 的本质： 函数内部是一个字典。
def show_kwargs(**kwargs):
print(type(kwargs)) # <class 'dict'>
print(kwargs) # {'name': 'Alice', 'age': 25}
show_kwargs(name="Alice", age=25)参数顺序规则
定义函数时，参数必须按以下顺序：
def func(位置参数, 默认参数, *args, **kwargs):
pass
# 示例
def demo(a, b=2, *args, **kwargs):
print(f"a={a}, b={b}")
print(f"args={args}")
print(f"kwargs={kwargs}")
demo(1, 3, 4, 5, x=10, y=20)
# a=1, b=3
# args=(4, 5)
# kwargs={'x': 10, 'y': 20}返回值
使用 return
函数通过 return 返回结果：
def square(x):
return x ** 2
result = square(4)
print(result) # 16多返回值
Python 函数可以同时返回多个值（实际是返回元组）：
def min_max(numbers):
return min(numbers), max(numbers)
minimum, maximum = min_max([3, 1, 4, 1, 5])
print(minimum) # 1
print(maximum) # 5
# 本质上返回的是元组
result = min_max([3, 1, 4])
print(result) # (1, 4)
print(type(result)) # <class 'tuple'>没有 return
如果函数没有 return，默认返回 None：
def say_hello():
print("Hello")
result = say_hello() # Hello
print(result) # None文档字符串（Docstring）
用三引号编写函数的说明文档：
def calculate_bmi(weight, height):
"""
计算 BMI 指数。
参数:
weight: 体重，单位千克
height: 身高，单位米
返回:
BMI 值
"""
return weight / (height ** 2)
# 查看文档
print(calculate_bmi.__doc__)作业
作业一：函数参数与列表操作综合
阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。
def add_items(base, items=None, *tags):
if items is None:
items = []
items.append(base)
for tag in tags:
items.append(tag)
return items
result1 = add_items(10)
print(result1)
result2 = add_items(20, [1, 2], 30, 40)
print(result2)
print(result1)作业二：关键字参数与字典操作综合
阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。
def merge_data(base, **extra):
result = base.copy() # 浅拷贝
for key, value in extra.items():
if key in result:
result[key] += value
else:
result[key] = value
return result
data = {"a": 10, "b": [1, 2]}
merged = merge_data(data, a=5, b=[3], c="hello")
print(merged)
print(len(merged))
print(merged.get("d", "not found"))作业三：多返回值与容器遍历综合
阅读以下代码，预测每行 print 的输出结果，并在注释中写出你的答案。
def split_data(data):
mid = len(data) // 2
return data[:mid], data[mid:]
nums = [1, 2, 3, 4, 5, 6]
first, second = split_data(nums)
print(first, second)
def find_indices(items, target):
indices = []
for i, item in enumerate(items):
if item == target:
indices.append(i)
return indices
scores = [85, 92, 85, 78, 85]
positions = find_indices(scores, 85)
print(positions)
result = second + [len(positions)]
print(result)作业四：函数综合编程
请按照要求实现以下三个函数，并编写测试代码手动调用每个函数，验证功能是否正确。
任务 1：列表扁平化
实现函数 flatten，接收一个可能包含嵌套列表的列表（如 [1, [2, 3], [[4], 5]]），返回一个将所有元素展开后的一维列表（如 [1, 2, 3, 4, 5]）。
nested1 = [1, [2, 3], [[4], 5]]
print(flatten(nested1)) # [1, 2, 3, 4, 5]
nested2 = [[[1]], 2, [3, [4, [5]]]]
print(flatten(nested2)) # [1, 2, 3, 4, 5]
print(flatten([])) # []
print(flatten([1, 2, 3])) # [1, 2, 3]任务 2：列表/元组转链表
实现函数 to_linked_list，接收一个列表或元组，将其转换为一个链表结构并返回。
linked1 = to_linked_list((1, 2, 3))
print(linked1)
# {'value': 1, 'next': {'value': 2, 'next': {'value': 3, 'next': None}}}
linked2 = to_linked_list([10, 20])
print(linked2)
# {'value': 10, 'next': {'value': 20, 'next': None}}
print(to_linked_list([])) # None任务 3：字典合并
实现函数 merge_dicts，接收不定数量的字典参数，将它们合并为一个大字典。
合并规则：求并集，如果有相同的键，后传入的字典中的值覆盖先传入的字典中的值（浅合并即可）
d1 = {"a": 1, "b": [1, 2]}
d2 = {"b": [3], "c": "hello"}
d3 = {"a": 10, "d": True}
merged = merge_dicts(d1, d2, d3)
print(merged)
# {'a': 10, 'b': [3], 'c': 'hello', 'd': True}
print(merge_dicts(d1))
# {'a': 1, 'b': [1, 2]}
print(merge_dicts())
# {}