Python作为一门灵活且强大的编程语言，其函数机制是构建模块化代码的核心基础。通过函数，开发者能够将重复逻辑封装为可复用的单元，提升代码的可维护性与可读性。Python添加函数的方式兼具简洁性与灵活性，既支持传统定义模式，也允许lambda表达式、装饰器等高级特性。函数的参数设计（如默认值、可变参数）与返回值管理进一步扩展了其适用场景，而作用域规则（如LEGB原则）则确保了变量管理的严谨性。此外，Python的函数本质是对象，支持高阶操作（如将函数作为参数传递或返回），这一特性为函数式编程提供了基础设施。从实际开发角度看，合理添加函数需综合考虑命名规范、参数校验、异常处理等多个维度，以平衡代码的简洁性与健壮性。

p ython怎么加函数

一、函数定义与语法规则

基础定义方式

Python通过`def`关键字定义函数，语法结构如下： ```python def function_name(parameters): """文档字符串""" # 函数体 return value ```

函数名遵循标识符规则，参数列表可包含位置参数、默认参数、可变参数（*args）和关键字参数（**kwargs）。例如：

```python def add(a, b=10, *args, **kwargs): return a + b ```

此函数支持必选参数`a`、默认参数`b`、任意数量的位置参数`args`和关键字参数`kwargs`。

参数类型示例说明
必选参数def func(a)调用时必须传递
默认参数def func(a=0)可省略赋值，使用默认值
可变参数def func(*args)接收任意数量的位置参数
关键字参数def func(**kwargs)接收任意数量的键值对

二、参数传递机制

参数传递的本质

Python采用“对象引用传递”机制，实参将引用传递给函数内部的形参。对于不可变对象（如整数、字符串），函数内修改不影响外部；对于可变对象（如列表、字典），修改会直接生效。

示例对比：

```python def modify_list(lst): lst.append(1) # 修改原列表

def modify_int(n):
n += 1 # 创建新对象

original_list = [0]
modify_list(original_list)

original_list变为[0, 1]

original_int = 10
modify_int(original_int)

original_int仍为10

<table border="1">  
<thead>  
<tr><th>对象类型</th><th>传递方式</th><th>函数内修改影响</th></tr>  
</thead>  
<tr><td>不可变对象</td><td>值传递（引用传递）</td><td>不影响外部</td></tr>  
<tr><td>可变对象</td><td>引用传递</td><td>直接影响外部</td></tr>  
</table>  

---

### 三、返回值与多值返回  
<H3><strong>返回值的灵活性</strong></H3>  
Python函数可通过`return`返回单个或多个值。多值返回时，实际返回的是一个元组，但语法上可省略括号。  
<p>示例：</p>  
```python  
def calculate(a, b):  
    sum_val = a + b  
    diff_val = a - b  
    return sum_val, diff_val  # 等价于return (sum_val, diff_val)  

result = calculate(5, 3)  
# result为(8, 2)，可通过索引或解包获取
返回值类型语法示例实际返回结构
单值return 5int
多值（显式）return a, b元组(a, b)
多值（隐式）return [a, b]列表[a, b]

四、作用域与闭包

LEGB规则解析

Python采用LEGB（Local→Enclosing→Global→Built-in）规则查找变量。若函数内部修改全局变量，需使用`global`声明；若需保留外部函数的局部变量，可使用`nonlocal`或闭包。

示例对比：

```python x = 10 # 全局变量

def outer():
global x # 声明修改全局变量
x = 20
def inner():
nonlocal x # 引用外层函数的x（需在嵌套函数中）
x = 30
inner()
print(x) # 输出30

outer()
print(x) # 输出20（全局变量被修改）

<table border="1">  
<thead>  
<tr><th>关键字</th><th>作用范围</th><th>示例场景</th></tr>  
</thead>  
<tr><td>global</td><td>全局作用域</td><td>修改全局变量</td></tr>  
<tr><td>nonlocal</td><td>外层函数作用域</td><td>嵌套函数中修改外层变量</td></tr>  
<tr><td>无声明</td><td>局部作用域</td><td>函数内部临时变量</td></tr>  
</table>  

---

### 五、匿名函数与Lambda表达式  
<H3><strong>Lambda的局限性与适用场景</strong></H3>  
Lambda表达式用于定义单行匿名函数，语法为`lambda params: expression`。它适用于简单操作，但无法包含复杂逻辑或多行语句。  
<p>示例对比：</p>  
```python  
# 普通函数  
def add(a, b):  
    return a + b  

# Lambda表达式  
add_lambda = lambda a, b: a + b
特性普通函数Lambda
语法复杂度支持多行、复杂逻辑仅限单行表达式
可复用性可直接调用需赋值给变量
适用场景通用场景临时回调（如sorted/key）

六、函数作为对象与高阶函数

函数的一等公民特性

Python中函数是对象，可赋值给变量、作为参数传递或返回。高阶函数是指接受函数作为参数或返回函数的函数。

示例：

```python def apply_func(func, value): return func(value)

result = apply_func(lambda x: x*2, 5) # 输出10

<table border="1">  
<thead>  
<tr><th>操作类型</th><th>示例代码</th><th>说明</th></tr>  
</thead>  
<tr><td>函数赋值</td><td>f = pow</td><td>将内置函数赋值给变量</td></tr>  
<tr><td>函数传递</td><td>sorted(lst, key=len)</td><td>将lambda作为参数传递</td></tr>  
<tr><td>函数返回</td><td>def maker(): return lambda x: x+1</td><td>返回新函数对象</td></tr>  
</table>  

---

### 七、装饰器与函数包装  
<H3><strong>装饰器的语法与实现</strong></H3>  
装饰器通过`@decorator`语法修改函数行为，本质是封装原函数并返回新函数。常见用途包括日志记录、权限校验等。  
<p>示例：</p>  
```python  
def log_decorator(func):  
    def wrapper(*args, **kwargs):  
        print(f"Calling {func.__name__}")  
        return func(*args, **kwargs)  
    return wrapper  

@log_decorator  
def say_hello():  
    print("Hello!")
装饰器类型示例代码功能
无参装饰器@decorator直接修改函数逻辑
带参装饰器@decorator(arg)通过闭包传递参数
类装饰器@ClassDecorator()基于类的方法包装

八、内置函数与特殊方法

Python内置函数的扩展能力

Python提供大量内置函数（如`map`、`filter`、`sorted`），可通过传递自定义函数扩展其功能。此外，特殊方法（如`__call__`）允许自定义对象模拟函数行为。

示例对比：

```python # 使用内置函数map result = map(lambda x: x*2, [1, 2, 3]) # [2,4,6]

自定义类模拟函数

class Multiplier:
def call(self, x):
return x * 3

multiplier = Multiplier()
result = multiplier(5) # 15

<table border="1">  
<thead>  
<tr><th>特性</th><th>内置函数</th><th>特殊方法</th></tr>  
</thead>  
<tr><td>功能扩展</td><td>通过lambda/函数参数定制行为</td><td>通过__call__实现对象调用</td></tr>  
<tr><td>性能优化</td><td>部分函数底层用C实现</td><td>依赖类实例的属性</td></tr>  
<tr><td>使用场景</td><td>数据处理、快速操作</td><td>面向对象式函数封装</td></tr>  
</table>  

---

<p>Python的函数机制不仅是语法层面的工具，更是连接代码逻辑与抽象思维的桥梁。从基础定义到高阶特性，函数的设计与使用直接影响代码的质量和效率。在实际开发中，需根据场景选择适当的参数类型（如默认值避免冗余）、合理控制作用域（避免变量冲突），并通过装饰器、高阶函数等特性提升代码的可扩展性。未来，随着Python对异步编程、类型注解等特性的支持深化，函数的定义方式可能进一步融合新兴范式（如协程函数），但其核心思想——封装复用与抽象分层——始终是编写高效代码的基石。