16函数

在 Python 中，**函数（Function）** 是一段**组织好的、可重复使用的代码块**，用于实现特定功能。它能将复杂逻辑分解为模块化的单元，提高代码的可读性、可维护性和复用性，是 Python 编程中组织代码的核心方式。

- **核心目的**：将 “实现特定功能的代码” 封装起来，通过 “调用函数” 重复使用，避免重复编写相同代码。
- **类比**：类似生活中的 “工具”—— 比如 “计算器”（函数）封装了 “计算” 功能，只需输入数字（参数），就能得到结果（返回值）。

## 语法

用def关键字定义函数，基本语法如下：

```python
def 函数名(参数列表):
    """文档字符串（可选，描述函数功能）"""
    # 函数体：实现功能的代码块（必须缩进）
    代码1
    代码2
    return 返回值  # 可选，返回函数执行结果

```

各部分说明：

1. **def**：定义函数的关键字（固定写法）。
2. **函数名**：遵循变量命名规则（小写字母、下划线分隔，如calculate_sum），需见名知意。
3. **参数列表**：括号内的变量，用于接收外部传入的数据（可选，无参数时写空括号()）。
4. **文档字符串（docstring）**：三引号包裹的说明文字，用于解释函数功能（可选，但推荐写，方便后续查看）。
5. **函数体**：缩进的代码块（通常 4 个空格），实现函数的具体逻辑。
6. **return**：返回函数的执行结果（可选），执行到return时函数会立即终止；若没有return，默认返回None。

例如：
```python
def add(a, b):
    """计算两个数的和"""
    result = a + b
    return result  # 返回计算结果

```

## 调用

定义函数后，需通过 “函数名 + 括号” 调用，才能执行其功能。调用时传入的实际数据称为 “实参”，函数定义时的参数称为 “形参”。

例如：

```python
def add(a, b):
    """计算两个数的和"""
    result = a + b
    return result  # 返回计算结果

sum_result = add(1, 2)
print(sum_result)
print(add(10, 20))
```

输出结果：

```python
3
30
```

## 位置参数（必选参数）

最基础的参数类型，调用时必须按**位置顺序**传入，数量与形参一致。

```python
def greet(name, age):
    print(f"你好，我叫{name}，今年{age}岁")

greet("张三", 30)
```

输出结果：
```python
你好，我叫张三，今年30岁
```

**注意**：若参数顺序错误，会导致逻辑错误：

```python
greet(30,"张三")
你好，我叫30，今年张三岁
```

## 关键字参数

调用时通过 “形参名=实参” 的形式传入，**无需考虑位置顺序**，提高代码可读性。

```python
def greet(name, age):
    print(f"你好，我叫{name}，今年{age}岁")
    
greet(age=30, name="张三") 
```

输出结果：

```python
你好，我叫张三，今年30岁
```

**混合使用**：位置参数必须放在关键字参数**前面**：

```python
greet("张三", age=30)  # 正确（位置参数在前，关键字参数在后）
greet(name="张三", 30)  # 错误（关键字参数不能在位置参数前）
```

##  默认参数

定义函数时给形参指定默认值（形参=默认值），调用时若不传入该参数，则使用默认值。

```python
def greet(name, age=18):
    print(f"你好，我叫{name}，今年{age}岁")

greet("张三")
greet("张三",40)
```

输出结果：

```python
你好，我叫张三，今年18岁
你好，我叫张三，今年40岁
```

**注意**：默认参数必须放在**位置参数后面**（否则报错）。

## 不定长参数（可变参数）

用于处理 “传入参数数量不确定” 的场景，分为两种：

- ***args**：接收**任意数量的位置参数**，打包成**元组**（tuple）。
- ****kwargs**：接收**任意数量的关键字参数**，打包成**字典**（dict）。

```python
def sum_numbers(*args):
    """计算任意个数字的和"""
    print("传入的参数：", args)  # args是元组
    return sum(args)

print(sum_numbers(1, 2, 3))  # 传入3个参数 → 输出：6
print(sum_numbers(10, 20, 30, 40))  # 传入4个参数 → 输出：100
print(sum_numbers())  # 可传入0个参数 → 输出：0

```

输出结果：

```python
传入的参数： (1, 2, 3)
6
传入的参数： (10, 20, 30, 40)
100
传入的参数： ()
0
```

```python
def print_info(** kwargs):
    """打印任意个关键字参数信息"""
    print("传入的参数：", kwargs)  # kwargs是字典
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=30, city="北京")

```

输出结果：

```python
传入的参数： {'name': '张三', 'age': 30, 'city': '北京'}
name: 张三
age: 30
city: 北京
```

**组合使用**：参数顺序必须是 “位置参数 → *args → 默认参数 → **kwargs”：

```python
def func(a, b, *args, c=0, **kwargs):
    print(f"a={a}, b={b}, args={args}, c={c}, kwargs={kwargs}")

func(1, 2, 3, 4, c=5, d=6, e=7)

```

输出结果：

```python
a=1, b=2, args=(3, 4), c=5, kwargs={'d': 6, 'e': 7}
```

## 返回值

return语句用于返回函数的执行结果，有以下特性：

**返回单个值 **：直接返回数据（任意类型）。

```python
def square(x):
    return x **2  # 返回x的平方
print(square(5))

```

输出结果：
```python
25
```

**返回多个值 **：用逗号分隔多个值，Python 会自动将其打包成元组。

```python
def get_info():
    name = "张三"
    age = 30
    return name, age  # 等价于return (name, age)

result = get_info()
print(result)  
# 可直接解包
name, age = get_info()
print(name, age)

```

输出结果：

```python
('张三', 30)
张三 30
```

**终止函数执行** ：return后的代码不会执行。

```python
def check_positive(x):
    if x > 0:
        return "正数"
    print("这行代码不会执行（若x>0）")  # 若x>0，return后不执行

print(check_positive(5)) 
```

输出结果：
```python
正数
```

**无返回值** ：若函数没有return，或return后无内容，默认返回None。

```python
def say_hello():
    print("Hello") 
result = say_hello()
print(result)  
```

输出结果：
```python
Hello
None
```

## 作用域

函数内部定义的变量（局部变量）与外部定义的变量（**全局变量**）有不同的 “可见范围”，称为 “作用域”。

**局部变量** ：在函数内部定义，仅在函数内部可见（函数外无法访问）。

```python
def func():
    local_var = "我是局部变量"
    print(local_var)

func()
print(local_var)

```

输出结果：

```python
Traceback (most recent call last):
  File "S:\Python\BaseCode\HelloWorld\Hello.py", line 6, in <module>
    print(local_var)  # 错误：函数外无法访问局部变量（NameError）
          ^^^^^^^^^
NameError: name 'local_var' is not defined
我是局部变量
```

**全局变量** ：

在函数外部定义，可在函数内部**读取**，但**修改**需用global关键字声明。

```python
global_var = "我是全局变量" 
def read_global():
    print(global_var)

def modify_global():
    global global_var  # 声明要修改全局变量
    global_var = "修改后的全局变量"

read_global()  
modify_global()
print(global_var)

```

输出结果：

```python
我是全局变量
修改后的全局变量
```

## 匿名函数

用lambda关键字定义的 “一句话函数”，语法简洁，适合实现简单逻辑（仅能包含一个表达式）。

**语法**：lambda 参数: 表达式（自动返回表达式结果）。

```python
# 等价于def add(a, b): return a + b
add = lambda a, b: a + b
print(add(3, 5))

# 配合内置函数使用（如排序）
students = [("张三", 20), ("李四", 18), ("王五", 22)]
# 按年龄排序（用lambda指定排序依据为元组的第二个元素）
students.sort(key=lambda x: x[1])
print(students)

```

输出结果：

```python
8
[('李四', 18), ('张三', 20), ('王五', 22)]
```

## 嵌套函数

函数内部可定义另一个函数，内部函数可访问外部函数的变量（闭包特性）。

```python
def outer_func(msg):
    def inner_func():
        print(f"消息：{msg}")  # 内部函数访问外部函数的msg

inner_func()  # 调用内部函数

outer_func("Hello World")
```

输出结果：

```python
8
[('李四', 18), ('张三', 20), ('王五', 22)]
```

## 递归函数

函数在内部调用自身，用于解决可分解为 “同类子问题” 的场景（如阶乘、斐波那契数列）。

**必须包含**：

- 基线条件（终止递归的条件，避免无限递归）；
- 递归条件（调用自身，且问题规模缩小）。

```python
def factorial(n):
    """计算n的阶乘（n! = n × (n-1) × ... × 1）"""
    if n == 1:  # 基线条件：n=1时返回1
        return 1
    return n * factorial(n - 1)  # 递归条件：调用自身，规模缩小

print(factorial(5)) 
```

输出结果：（5! = 5×4×3×2×1）
```python
120	
```

## 高阶函数

接受**函数作为参数**，或**返回一个函数**的函数（如map、filter、sorted）。

```python
# 示例：用map（高阶函数）将列表中每个元素平方
def square(x):
    return x** 2

numbers = [1, 2, 3, 4]
result = map(square, numbers)  # map接收函数square和列表numbers
print(list(result))
```

输出结果：

```python
[1, 4, 9, 16]
```

## 模块

在 Python 中，将函数存储在**模块（Module）** 中是代码组织和复用的核心方式。模块本质上是一个包含 Python 代码（函数、类、变量等）的.py文件，通过导入模块，可以在其他脚本中重复使用这些函数，避免代码冗余。

- **模块**：扩展名为.py的 Python 文件（如my_functions.py），里面可定义函数、类、变量等。
- **作用**：将相关功能的函数集中管理，实现 “一次定义，多处复用”，让代码结构更清晰。

例如现在有一个名为calculator.py的文件，在其中定义几个数学相关的函数：

```python
def add(a, b):
    """计算两个数的和"""
    return a + b

def subtract(a, b):
    """计算两个数的差"""
    return a - b

def multiply(a, b):
    """计算两个数的积"""
    return a * b

# 模块中也可以定义变量
PI = 3.14159
```

创建另一个 Python 脚本（如main.py），通过 “导入模块” 来使用calculator.py中定义的函数。

导入模块的方式有多种，根据需求选择：

**1.导入整个模块 （import 模块名）**

```python
import 模块名  # 导入整个模块
模块名.函数名()  # 通过"模块名.函数名"调用函数
```

```python
import calculator

# 使用模块中的函数（需加模块名前缀）
print(calculator.add(3, 5))  # 输出：8
print(calculator.subtract(10, 4))  # 输出：6

# 使用模块中的变量
print("圆周率：", calculator.PI)  # 输出：圆周率：3.14159
```

**2.导入模块中的特定函数 （from 模块名 import 函数名）**

```python
from 模块名 import 函数1, 函数2, 变量  # 只导入需要的函数/变量
函数名()  # 直接使用函数名（无需模块名前缀）
```

```python
# 只导入calculator中的add和PI
from calculator import add, PI

# 直接使用函数和变量（无需加模块名）
print(add(2, 8))  # 输出：10
print(PI)  # 输出：3.14159

# 未导入的函数无法直接使用（需用方式1调用）
# print(subtract(5, 2))  # 报错：NameError: name 'subtract' is not defined

```

**3.导入模块中的所有内容 （from 模块名 import *）**

```python
from 模块名 import *  # 导入模块中所有公开的函数、变量（不推荐，可能导致命名冲突）
函数名()  # 直接使用所有函数/变量
```

```python
# 导入calculator中的所有内容
from calculator import *

# 直接使用所有函数和变量
print(add(1, 1))  # 输出：2
print(subtract(5, 3))  # 输出：2
print(multiply(2, 6))  # 输出：12
print(PI)  # 输出：3.14159

```

**4.给模块或者函数起别名 （as 关键词）**

当模块名或函数名过长，或存在命名冲突时，可通过as指定别名。

```python
import 模块名 as 别名  # 给模块起别名
from 模块名 import 函数名 as 别名  # 给函数起别名
```

```python
# 给模块起别名（简化调用）
import calculator as calc
print(calc.multiply(3, 7))  # 输出：21

# 给函数起别名（解决冲突）
from calculator import add as plus
print(plus(4, 6))  # 输出：10（用别名调用）
```

**注意**

- import 模块名：导入**整个模块**（模块内的所有函数、变量、类等），但这些对象不会直接进入当前脚本的命名空间，而是被 “包裹” 在模块名对应的命名空间中。
- from 模块名 import *：导入模块中**所有公开的对象**（函数、变量、类等，具体由模块的__all__变量控制，若未定义则导入非下划线开头的对象），并将这些对象直接放入当前脚本的命名空间。

- import 模块名：必须通过 **模块名.对象名** 的方式访问模块内的对象（需要加模块名前缀）。
- from 模块名 import *：可以**直接通过对象名** 访问（无需模块名前缀）。

**命名空间**：可以理解为 “变量 / 对象的存储区域”，不同命名空间中的同名对象互不干扰。

## 总结

函数是 Python 中组织代码的核心单元，核心要点：

- 用def定义，通过 “函数名 (参数)” 调用，用return返回结果；
- 代码复用：定义一次，可在多处调用，避免重复编写相同逻辑；
- 模块化：将复杂问题分解为多个函数，每个函数负责单一功能，便于理解和维护；
- 抽象逻辑：隐藏实现细节，只需关注 “函数做什么”（输入输出），无需关心 “怎么做”；
- 支持多种参数类型（位置参数、关键字参数、默认参数、不定长参数），灵活处理不同输入；
- 变量有作用域（局部 / 全局），需注意访问和修改规则；
- 包含匿名函数、递归函数、高阶函数等特殊类型，适应不同场景。