Python函数怎么定义？从入门到精通全解析

Python中定义函数的核心是使用def关键字，并可通过参数类型和作用域规则实现灵活的功能。1.定义函数需用def关键字后接函数名、括号及参数，最后以冒号结束，函数体需缩进；2.函数参数包括位置参数、关键字参数、默认参数和可变参数（args与*kwargs），分别用于不同场景的灵活传参；3.函数作用域遵循LEGB法则，即局部、闭包外、全局和内建作用域的查找顺序，且可通过global关键字修改全局变量；4.闭包是内部函数引用外部函数变量，并在外部函数执行完后仍可访问这些变量；5.高阶函数可接受或返回函数，用于实现如map、filter等通用逻辑；6.装饰器是语法糖，通过包装函数为原有函数添加新功能，常用于日志、性能分析、权限校验等场景，且可用functools.wraps保留原函数元数据。

Python中定义函数的核心就是def关键字，它允许我们封装一段可重用的代码逻辑，让程序结构更清晰，也更容易维护。这就像是给你的代码块起个名字，以后想用的时候，直接叫它的名字就行了。

解决方案

要定义一个Python函数，你需要用def关键字，后面跟着你给函数起的名字，然后是一对括号，里面可以放参数（也可以不放），最后是一个冒号。函数体的内容需要缩进。

def my_first_function():
    """
    这是一个非常简单的函数，它只打印一句话。
    """
    print("Hello from my function!")

# 调用函数
my_first_function()

def add_numbers(a, b):
    """
    这个函数接收两个参数a和b，并返回它们的和。
    """
    result = a + b
    return result

# 调用并使用返回值
sum_result = add_numbers(5, 3)
print(f"5 + 3 = {sum_result}")

在我看来，函数最强大的地方在于它的“抽象”能力。我们把一个复杂的任务分解成一个个小函数，每个函数只负责一小部分，这样不仅代码看起来没那么乱，调试起来也方便得多。而且，当你需要修改某个逻辑时，往往只需要改动一个函数，而不是牵一发而动全身。这种模块化的思维，我觉得是写好代码的基础。

函数参数的奥秘：位置、关键字、默认与可变参数

说起函数，参数绝对是个绕不开的话题。这部分内容，在我刚学Python的时候，确实花了一些时间去消化，因为它的灵活性有时候会让人有点“迷茫”。但一旦你掌握了，你会发现它真的能让你的函数变得非常强大和适应性强。

我们先从最基础的开始：

• 位置参数 (Positional Arguments): 这是最直观的，你传参数的顺序，就是函数接收参数的顺序。

  def greet(name, message):
      print(f"Hello, {name}! {message}")
  
  greet("Alice", "Hope you have a great day!") # 顺序不能错

• 关键字参数 (Keyword Arguments): 这种方式允许你通过参数名来传递值，顺序就不那么重要了。这在函数有很多参数时特别有用，可以提高代码的可读性。

  greet(message="How are you doing?", name="Bob") # 顺序调换了也OK

• 默认参数 (Default Arguments): 有时候，函数的一些参数会有常用值。你可以给它们设置一个默认值，这样调用时如果不想指定，就可以省略。但要注意，带默认值的参数必须放在不带默认值的参数后面。

  def send_email(to_address, subject="No Subject", body=""):
      print(f"Sending email to: {to_address}")
      print(f"Subject: {subject}")
      print(f"Body: {body}")
  
  send_email("user@example.com") # 使用默认主题和空内容
  send_email("another@example.com", subject="Meeting Reminder") # 只覆盖主题

• *可变参数 (`args和kwargs`): 这两个是真正让函数变得“通用”的利器。

  • *args (Arbitrary Positional Arguments): 当你不确定函数会被传入多少个位置参数时，可以用*args来收集它们。它会将所有额外的、未被明确定义的位置参数打包成一个元组 (tuple)。

    def calculate_sum(*numbers):
        total = 0
        for num in numbers:
            total += num
        print(f"Sum: {total}")
    
    calculate_sum(1, 2, 3)
    calculate_sum(10, 20, 30, 40, 50)

  • **kwargs (Arbitrary Keyword Arguments): 类似地，当你不知道会有多少个关键字参数传入时，**kwargs就派上用场了。它会将所有额外的关键字参数打包成一个字典 (dictionary)。

    def print_profile(**details):
        print("User Profile:")
        for key, value in details.items():
            print(f"  {key.replace('_', ' ').title()}: {value}")
    
    print_profile(name="Charlie", age=30, city="New York")
    print_profile(product="Laptop", price=1200, category="Electronics", brand="XYZ")

实际工作中，我发现合理利用这些参数类型能让API设计得非常优雅。比如，一个配置加载函数，可能需要固定路径参数，但其他配置项就可以用**kwargs灵活传入。这避免了写一堆重载函数，代码也显得更精炼。

深入理解函数作用域：LEGB法则与闭包

函数作用域，这块内容有时候会让人感到困惑，尤其是在涉及嵌套函数或者变量修改时。但理解它，是避免一些奇怪bug的关键。Python有一套很清晰的规则来决定变量的查找顺序，这就是著名的LEGB法则。

• L (Local): 局部作用域。函数内部定义的变量，只能在该函数内部访问。函数执行完毕，局部变量通常就会被销毁。

  def my_func():
      x = 10 # x是局部变量
      print(x)
  my_func()
  # print(x) # 这会报错，因为x在函数外部不可见

• E (Enclosing): 闭包函数外的函数作用域（也叫非局部作用域）。当一个函数嵌套在另一个函数内部时，内部函数可以访问外部（但非全局）函数的变量。

  def outer_func():
      y = 20 # y是outer_func的局部变量，对inner_func来说是Enclosing
      def inner_func():
          print(y) # inner_func可以访问y
      inner_func()
  outer_func()

• G (Global): 全局作用域。在模块的最顶层定义的变量，可以在模块的任何地方被访问。

  z = 30 # z是全局变量
  def another_func():
      print(z) # 函数内部可以访问全局变量
  another_func()

  如果你想在函数内部修改一个全局变量，需要使用global关键字明确声明。

  count = 0
  def increment_global():
      global count # 声明要修改的是全局变量count
      count += 1
  increment_global()
  print(count) # 输出1

• B (Built-in): 内建作用域。Python预定义的一些函数和变量，比如print(), len(), True, False等。它们始终可用。

当Python查找一个变量时，它会按照L -> E -> G -> B 的顺序去查找。找到第一个匹配的就停止。

闭包 (Closures): 闭包是一个挺有意思的概念，它发生在当一个内部函数引用了外部（非全局）函数的变量，并且外部函数已经执行完毕，但内部函数仍然可以访问这些变量时。这本质上是内部函数“记住了”它被创建时的环境。

def make_multiplier(x):
    def multiplier(y):
        return x * y # multiplier引用了外部函数的x
    return multiplier

# 这里的double和triple就是闭包
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))  # 输出 10 (2 * 5)
print(triple(5))  # 输出 15 (3 * 5)

闭包在很多高级编程模式中都有应用，比如装饰器（后面会提到）、回调函数、以及一些工厂函数。理解闭包对于深入理解Python的函数式编程特性至关重要。

玩转高阶函数与装饰器：代码复用的艺术

Python的函数是“一等公民”，这意味着函数可以像普通数据一样被传递、赋值、作为参数传递给其他函数，或者从其他函数返回。这种特性为高阶函数和装饰器奠定了基础，它们是Python中实现代码复用和功能增强的强大工具。

高阶函数 (Higher-Order Functions): 简单来说，高阶函数就是那些接受一个或多个函数作为参数，或者返回一个函数的函数。这听起来有点抽象，但其实我们经常用到。比如map(), filter(), sorted()这些内置函数，都是典型的高阶函数。

# 示例：使用map()将列表中的每个数字平方
numbers = [1, 2, 3, 4]
squared_numbers = list(map(lambda x: x * x, numbers))
print(squared_numbers) # 输出 [1, 4, 9, 16]

# 示例：一个自定义的高阶函数
def apply_operation(func, a, b):
    return func(a, b)

def add(x, y):
    return x + y

def multiply(x, y):
    return x * y

print(apply_operation(add, 10, 5))      # 输出 15
print(apply_operation(multiply, 10, 5)) # 输出 50

高阶函数让我们的代码更加灵活和通用，你可以编写一个通用的处理逻辑，然后通过传入不同的函数来改变其具体行为。

装饰器 (Decorators): 装饰器是Python中一个非常酷的语法糖，它允许你在不修改原有函数代码的情况下，给函数添加额外的功能。这有点像给函数穿上一件“外套”，这件外套在函数执行前后做一些事情。

一个装饰器本质上是一个高阶函数，它接受一个函数作为输入，并返回一个新的函数（通常是原函数被包装后的版本）。

def simple_decorator(func):
    def wrapper(*args, **kwargs):
        print("Function is about to be called.")
        result = func(*args, **kwargs) # 调用原始函数
        print("Function has finished execution.")
        return result
    return wrapper

@simple_decorator
def say_hello(name):
    print(f"Hello, {name}!")

@simple_decorator
def calculate_power(base, exponent):
    return base ** exponent

say_hello("World")
# 输出:
# Function is about to be called.
# Hello, World!
# Function has finished execution.

result = calculate_power(2, 3)
print(f"2 to the power of 3 is: {result}")
# 输出:
# Function is about to be called.
# Function has finished execution.
# 2 to the power of 3 is: 8

@simple_decorator语法糖等价于 say_hello = simple_decorator(say_hello)。

装饰器在实际开发中非常常见，比如：

• 日志记录: 在函数执行前后打印日志。
• 性能分析: 测量函数执行时间。
• 权限校验: 检查用户是否有权限执行某个函数。
• 缓存: 缓存函数的结果，避免重复计算。

一个常见的实践是使用functools.wraps来保留被装饰函数的元数据（如函数名、文档字符串）。

import functools

def another_decorator(func):
    @functools.wraps(func) # 保持原函数的元数据
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}...")
        result = func(*args, **kwargs)
        print(f"{func.__name__} finished.")
        return result
    return wrapper

@another_decorator
def my_function_with_docstring(param):
    """This is a function that does something."""
    return f"Processed: {param}"

print(my_function_with_docstring("data"))
print(my_function_with_docstring.__name__)    # 输出 my_function_with_docstring
print(my_function_with_docstring.__doc__)     # 输出 This is a function that does something.

没有@functools.wraps的话，__name__会是wrapper，__doc__也会丢失。这在调试和生成文档时可能会造成困扰。

在我看来，掌握了高阶函数和装饰器，你才算真正触及了Python函数式编程的精髓。它们不仅让代码更简洁，也让功能扩展变得异常优雅，是写出“Pythonic”代码的重要一步。