当前位置：首页 > 文章列表 > 文章 > python教程 > Python函数定义与使用教程

Python函数定义与使用教程

2025-09-16 19:00:40 0浏览收藏

Python函数是代码复用的关键，本文深入解析了Python函数的定义与调用方法，包括使用`def`关键字定义函数，以及如何通过函数名加参数进行调用。函数不仅可以返回值，还能支持多种参数类型，如位置参数、关键字参数和默认参数等。文章还详细讲解了Python的作用域LEGB规则和闭包的概念，闭包能够捕获外部变量，进一步提升代码的复用性和灵活性。掌握这些技巧，能让你编写出更高效、更易维护的Python代码，提升开发效率。

定义函数用def，调用函数直接使用函数名加参数。函数可返回值、支持多种参数类型，作用域遵循LEGB规则，闭包能捕获外部变量，提升代码复用与灵活性。

python中如何定义和调用函数_Python函数定义与调用基础

在Python里，定义一个函数本质上就是给一段你想要重复使用的代码块一个名字，并指定它需要哪些输入（参数）。而调用函数，则是通过这个名字去执行那段代码，并提供它所需的具体输入。它让你的代码模块化、可读性更高，也更容易维护——想想看，如果一段逻辑需要在十个地方用到，你肯定不想复制粘贴十次，对吧？

解决方案

在Python中定义函数，我们使用def关键字，后面跟着函数名，然后是一对圆括号，里面可以放参数（也可以没有），最后是一个冒号。函数体需要缩进。调用函数则简单得多，直接写函数名，后面跟上圆括号，并在里面提供实际的参数。

一个最基本的函数定义和调用是这样的：

def greet(name):
    """
    这个函数用于向指定的人打招呼。
    """
    message = f"你好，{name}！欢迎来到Python的世界。"
    print(message)

# 调用函数
greet("张三")
greet("李四")

这里，greet就是函数名，name是它的一个参数。当你调用greet("张三")时，字符串"张三"就被赋值给了函数内部的name变量。

函数还可以返回一个值，使用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的函数，并写出更高级、更优雅的代码。