本文平台介绍了Python函数的核心知识，涵盖函数定义、调用、参数类型（位置/关键字/默认/可变参数）、返回值、匿名函数、闭包和装饰器等关键概念。重点解析了参数传递机制，包括*args和**kwargs的使用；说明了闭包保存状态的特性和装饰器增强函数功能的作用；列举了常用内置函数如map/filter/sorted等。文章通过代码示例演示了函数模块化设计、代码复用等优势，并对比了

一、函数目的

• 代码复用：避免重复编写相同逻辑。
• 模块化设计：将复杂任务拆分为小而独立的功能单元。
• 提高可读性：通过函数名直观表达代码意图。

二、函数定义与声明

在 Python 中，函数定义即同时完成声明和实现：

def function_name(parameters):
"""函数文档字符串"""
# 函数体
return result  # 返回值（可选）

三、函数调用

通过函数名和实参触发执行：

def wake_up(name,n):
"""
叫醒服务
"""
for i in range(n):
print(f"醒醒，起床，{name}")
wake_up("小明",3)

四、参数类型

1. 位置参数（Positional Arguments）

按顺序匹配形参：

def power(x, n):
return x ** n
power(2, 3)  # 2³ = 8

2. 关键字参数（Keyword Arguments）

通过参数名指定值，可打乱顺序：

power(n=3, x=2)  # 等价于 power(2, 3)

3. 默认参数（Default Arguments）

形参指定默认值，调用时可省略：

def greet(name="World"):
return f"Hello, {name}!"
greet()       # 输出: "Hello, World!"
greet("Alice")  # 输出: "Hello, Alice!"

4. *可变参数（args）

接收任意数量的位置参数，转为元组：

def sum_all(*args):
return sum(args)
sum_all(1, 2, 3)  # 输出: 6

5. ** 关键字可变参数（kwargs）

接收任意数量的关键字参数，转为字典：

def print_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
print_info(name="Alice", age=30)
# 输出:
# name: Alice
# age: 30

 6. 组合参数

def complex_func(a, b=10, *args, **kwargs):
print(f"a={a}, b={b}, args={args}, kwargs={kwargs}")
complex_func(1, 2, 3, 4, x=5, y=6)
# 输出: a=1, b=2, args=(3, 4), kwargs={'x': 5, 'y': 6}

五、返回值

单返回值：

def get_name():
return "Alice"

多返回值（元组）：

def get_info():
return "Alice", 30  # 等价于 (("Alice", 30))
name, age = get_info()  # 元组解包

无返回值（默认返回 None）：

def print_hello():
print("Hello")
result = print_hello()  # result 为 None

六、匿名函数（Lambda）

用于创建简单的一次性函数：

# 普通函数
def add(x, y):
return x + y
# 等价的 lambda 函数
add = lambda x, y: x + y
# 直接使用 lambda
result = (lambda x, y: x * y)(3, 4)  # 输出: 12
numbers = [3, 1, 4, 2]
sorted(numbers, key=lambda x: -x)  # 降序排序：[4, 3, 2, 1]

七、闭包（Closure）

• 定义：内部函数引用外部函数的变量，并返回该内部函数。
• 作用：保存函数状态，避免全局变量。

示例：

def outer(x):
def inner(y):
return x + y  # 引用外部变量 x
return inner
closure = outer(10)
print(closure(5))  # 输出: 15（x=10 被保存在闭包中）

八、装饰器（Decorator）

• 作用：在不修改原函数代码的情况下，扩展其功能。
• 本质：返回函数的高阶函数。

示例：计时装饰器

import time
def use_time(use):
def use_time1():
start = time.time()
use()
end = time.time()
print(f"使用时间为{end - start}")
return use_time1
import random
l = [random.randint(1,100)for i in range(20)]
@use_time
def sort1():
for i in range(1,len(l)):
for j in range(len(l) - i):
if l[j] > l[j+1]:
l[j],l[j+1] = l[j+1],l[j]
print(l)
sort1()
@use_time
def sort2():
for i in range(len(l)):
min_num = i
for j in range(i+1,len(l)):
if l[min_num] > l[j]:
min_num = j
l[min_num],l[i] = l[i],l[min_num]
print(l)
sort2()

九、内置函数

Python 自带的常用函数（部分示例）：

函数	功能描述	示例
len(seq)	返回序列长度	len([1,2,3]) → 3
sum(iter)	计算可迭代对象元素的和	sum([1,2,3]) → 6
max(iter)	返回最大值	max([1,5,3]) → 5
map(func, iter)	对每个元素应用函数	list(map(lambda x:x*2, [1,2])) → [2,4]
filter(func, iter)	过滤元素	list(filter(lambda x:x>0, [-1,2])) → [2]
sorted(iter)	返回排序后的新列表	sorted([3,1,2]) → [1,2,3]
zip(*iterables)	并行迭代多个序列	list(zip([1,2], ['a','b'])) → [(1,'a'), (2,'b')]

十、关键对比

概念	特点
参数 vs 实参	参数是函数定义时的变量（如 def func(x) 中的 x），实参是调用时传递的值（如 func(1) 中的 1）。
位置参数 vs 关键字参数	位置参数按顺序匹配，关键字参数按名称匹配，可混用但关键字参数必须在位置参数之后。
闭包 vs 装饰器	闭包保存外部变量状态，装饰器是闭包的应用，用于增强函数功能。

十一、总结

1. 参数传递机制（位置、关键字、默认、可变参数）。
2. 高阶函数（如装饰器）和闭包的应用。
3. 内置函数的高效使用（避免重复造轮子）。