定义函数用def，调用函数直接使用函数名加参数。函数可返回值、支持多种参数类型，作用域遵循LEGB规则，闭包能捕获外部变量，提升代码复用与灵活性。
在Python里，定义一个函数本质上就是给一段你想要重复使用的代码块一个名字，并指定它需要哪些输入（参数）。而调用函数，则是通过这个名字去执行那段代码，并提供它所需的具体输入。它让你的代码模块化、可读性更高，也更容易维护——想想看，如果一段逻辑需要在十个地方用到，你肯定不想复制粘贴十次，对吧？
解决方案
在Python中定义函数，我们使用
def
关键字，后面跟着函数名，然后是一对圆括号，里面可以放参数（也可以没有），最后是一个冒号。函数体需要缩进。调用函数则简单得多，直接写函数名，后面跟上圆括号，并在里面提供实际的参数。
一个最基本的函数定义和调用是这样的：
def greet(name): """ 这个函数用于向指定的人打招呼。 """ message = f"你好，{name}！欢迎来到Python的世界。" print(message) # 调用函数 greet("张三") greet("李四")
这里，
greet
就是函数名，
name
是它的一个参数。当你调用
greet("张三")
时，字符串”张三”就被赋值给了函数内部的
name
变量。
立即学习“Python免费学习笔记（深入）”；
函数还可以返回一个值，使用
return
语句。这非常有用，因为很多时候我们不只是想让函数执行一个动作（比如打印），更希望它能计算出某个结果并供程序的其他部分使用。
def add(a, b): """ 计算两个数的和并返回。 """ result = a + b return result # 调用函数并获取返回值 sum_result = add(5, 3) print(f"5 + 3 = {sum_result}") # 输出：5 + 3 = 8 another_sum = add(10, 20) print(f"10 + 20 = {another_sum}") # 输出：10 + 20 = 30
我个人觉得，
return
是函数最强大的特性之一。它让函数从一个“执行器”变成了一个“计算器”，极大地提升了代码的表达能力和复用性。
Python函数参数有哪些巧妙的玩法？
当我们谈论函数的输入，也就是参数，Python提供了相当多的灵活性，这远不止简单的位置匹配。理解这些不同类型的参数，能让你写出更健壮、更易用的函数。
-
位置参数 (Positional Arguments)：这是最常见的，参数的传递顺序必须与定义时一致。
def describe_person(name, age, city): print(f"{name}，{age}岁，来自{city}。") describe_person("小明", 25, "北京") # describe_person(25, "小明", "北京") # 顺序错误会导致逻辑混乱这种方式直观，但当参数多起来时，就容易搞混顺序。
-
关键字参数 (Keyword Arguments)：通过
key=value
的形式传递，不依赖位置，提高了代码的可读性，也避免了参数顺序的混淆。
def describe_person(name, age, city): print(f"{name}，{age}岁，来自{city}。") describe_person(age=30, city="上海", name="小红") # 顺序无关紧要我经常在参数较多或者有些参数含义不那么明显时，倾向于使用关键字参数。
-
默认参数 (Default Arguments)：在定义函数时为参数指定一个默认值。如果调用时没有提供该参数，就使用默认值。
def send_email(receiver, subject="无主题", body=""): print(f"发送邮件给：{receiver}") print(f"主题：{subject}") print(f"内容：{body}") send_email("alice@example.com") # 使用默认主题和空内容 send_email("bob@example.com", subject="会议通知") # 仅覆盖主题这里有个小陷阱，默认值如果是可变对象（如列表、字典），在多次调用中会共享同一个对象，这通常不是你想要的。比如：
def append_item(item, my_list=[]): # 错误示范！ my_list.append(item) return my_list print(append_item(1)) # [1] print(append_item(2)) # [1, 2] -- 意料之外！
正确的做法是使用
None
作为默认值，并在函数内部判断：
def append_item_correct(item, my_list=None): if my_list is None: my_list = [] my_list.append(item) return my_list print(append_item_correct(1)) # [1] print(append_item_correct(2)) # [2] -- 这才是我们想要的
这个细节，我个人在初学时就踩过坑，所以每次用到默认参数都会特别留意。
-
*可变位置参数 (`args
)**：当你不知道函数会被传入多少个位置参数时，可以使用
*args`来收集它们，它们会被打包成一个元组。
def calculate_sum(*numbers): total = 0 for num in numbers: total += num return total print(calculate_sum(1, 2, 3)) # 6 print(calculate_sum(10, 20, 30, 40, 50)) # 150
-
可变关键字参数 (`kwargs
)**：类似
*args`，但它收集的是任意数量的关键字参数，并将它们打包成一个字典。
def print_profile(**details): for key, value in details.items(): print(f"{key}: {value}") print_profile(name="小王", age=28, occupation="工程师")*args
和
**kwargs
的组合使用非常强大，比如在编写装饰器或需要转发参数的函数时。
Python函数如何优雅地处理返回值？
函数的返回值是它与外部世界沟通的桥梁。理解如何高效、清晰地处理返回值，对于构建可维护的代码至关重要。
-
单个返回值：这是最常见的，函数执行计算后返回一个单一的结果。
def square(x): return x * x result = square(4) # result 为 16
-
多个返回值（以元组形式）：Python允许函数看起来返回多个值，实际上它返回的是一个元组。调用者可以通过解包（unpacking）来获取这些值。
def get_min_max(numbers): if not numbers: return None, None # 处理空列表的情况 return min(numbers), max(numbers) data = [3, 1, 4, 1, 5, 9, 2, 6] minimum, maximum = get_min_max(data) print(f"最小值：{minimum}，最大值：{maximum}") # 最小值：1，最大值：9 # 如果你只关心其中一个，也可以这样 _, max_val = get_min_max(data) print(f"只取最大值：{max_val}")这种返回多个值的方式，我个人觉得非常Pythonic，比在其他语言中通过引用传递或者返回一个自定义对象要简洁得多。
-
不显式返回 (
return None
)：如果函数没有明确的
return
语句，或者只有
return
而没有跟任何值，它会隐式地返回
None
。
def do_nothing(): pass # 什么也不做 def print_message(msg): print(msg) return # 显式返回None result1 = do_nothing() result2 = print_message("Hello") print(f"do_nothing返回：{result1}") # do_nothing返回：None print(f"print_message返回：{result2}") # print_message返回：None理解
None
的存在很重要。当一个函数可能因为某种条件失败，或者没有结果时，返回
None
是一种常见的模式。例如，在一个查找函数中，如果没有找到目标，返回
None
比抛出异常更“温和”。
-
尽早返回 (Early Exit)：在函数内部，如果某个条件满足，可以立即
return
，避免后续不必要的计算。这有助于简化逻辑，提高代码可读性。
def is_positive(number): if not isinstance(number, (int, float)): return False # 如果不是数字，直接返回False if number > 0: return True return False # 否则返回False
这种模式让函数的逻辑路径更清晰，避免了深层嵌套的
if/else
。我发现，很多时候，通过尽早处理“边缘情况”或“失败条件”，可以大大简化主逻辑。
Python函数作用域（Scope）与闭包（Closure）的深度解析
理解Python中变量的作用域（Scope）是编写可靠函数的基础，而闭包（Closure）则是在此基础上更高级且强大的概念。
-
作用域（Scope）： Python中的作用域遵循LEGB原则：
- L (Local)：函数内部定义的变量。它们只在该函数内部可见。
- E (Enclosing function locals)：嵌套函数（内层函数）中，可以访问外层函数（非全局）的局部变量。
- G (Global)：在模块级别（文件顶部）定义的变量。它们在整个模块中都可见。
- B (Built-in)：Python内置的名称，如
print
、
len
等。
一个经典的例子：
x = "全局变量" # Global def outer_function(): y = "外部函数的局部变量" # Enclosing def inner_function(): z = "内部函数的局部变量" # Local print(x) # 访问全局变量 print(y) # 访问外部函数的局部变量 print(z) # 访问内部函数的局部变量 inner_function() # print(z) # 错误：z不在outer_function的作用域内 outer_function() # print(y) # 错误：y不在全局作用域内
这里有个常见的陷阱，如果你在函数内部尝试修改一个全局变量，Python会默认创建一个同名的局部变量，而不是修改全局变量。如果你真的想修改全局变量，需要使用
global
关键字：
count = 0 def increment_bad(): count = 1 # 这是一个新的局部变量，不是修改全局的count print(f"局部count: {count}") def increment_good(): global count # 声明要修改的是全局变量 count += 1 print(f"全局count: {count}") increment_bad() # 输出：局部count: 1 print(f"全局count（未变）：{count}") # 输出：全局count（未变）：0 increment_good() # 输出：全局count: 1 print(f"全局count（已变）：{count}") # 输出：全局count（已变）：1对于嵌套函数，如果你想在内层函数修改外层函数的局部变量，需要使用
nonlocal
关键字。这在闭包中尤为重要。
-
闭包（Closure）： 当一个内层函数引用了外层函数的局部变量，并且外层函数已经执行完毕，但内层函数仍然可以访问和操作那些变量时，我们就说这个内层函数形成了一个闭包。 闭包的核心在于：函数及其创建时所处的环境（即它能访问的非全局变量）的组合。
def make_multiplier(x): def multiplier(y): return x * y # multiplier 引用了外层函数的 x return multiplier # 返回内层函数 # 创建两个不同的乘法器 times_3 = make_multiplier(3) times_5 = make_multiplier(5) print(times_3(10)) # 输出：30 (x=3, y=10) print(times_5(10)) # 输出：50 (x=5, y=10)
在这个例子中，
make_multiplier
函数执行完毕后，它的局部变量
x
理论上应该被销毁。但是，由于
multiplier
函数引用了
x
，Python的闭包机制确保了
x
的值（无论是3还是5）被“记住”了，并绑定到了各自返回的
multiplier
函数实例上。
闭包在很多场景下都非常有用，比如：
- 装饰器 (Decorators)：Python装饰器就是闭包的一个典型应用，它允许你在不修改原函数代码的情况下，给函数添加额外的功能。
- 数据封装：可以模拟私有变量，隐藏内部状态。
- 延迟计算：创建一个函数，在未来某个时刻执行，并使用创建时捕获的环境。
我个人觉得，闭包是Python函数式编程的一个重要基石，它让代码更具表达力和灵活性。理解了作用域和闭包，你就能更好地掌握Python的函数，并写出更高级、更优雅的代码。
word python go app ai python函数 代码复用 作用域 代码可读性 Python print if 封装 局部变量 全局变量 字符串 数据封装 引用传递 闭包 len function 对象 作用域 default