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免费学习笔记（深入）”；
函数参数的奥秘：位置、关键字、默认与可变参数
说起函数，参数绝对是个绕不开的话题。这部分内容，在我刚学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 = 0def increment_global(): global count # 声明要修改的是全局变量count count += 1increment_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 + ydef multiply(x, y): return x * yprint(apply_operation(add, 10, 5)) # 输出 15print(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_decoratordef say_hello(name): print(f"Hello, {name}!")@simple_decoratordef calculate_power(base, exponent): return base ** exponentsay_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 functoolsdef 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_decoratordef 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_docstringprint(my_function_with_docstring.__doc__) # 输出 This is a function that does something.
没有@functools.wraps的话，__name__会是wrapper，__doc__也会丢失。这在调试和生成文档时可能会造成困扰。
在我看来，掌握了高阶函数和装饰器，你才算真正触及了Python函数式编程的精髓。它们不仅让代码更简洁，也让功能扩展变得异常优雅，是写出“Pythonic”代码的重要一步。
以上就是Python函数如何定义？从入门到精通指南的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1365293.html
微信扫一扫 
支付宝扫一扫 
