---
fid: 20240201-125656
title: 3分钟了解 Python 函数
tags: function, function basic
---


# 快速了解 Python 函数

本节通过一个实例来学习函数的不同类型的参数的用法，体会函数的功能及易用性是如何随着不同参数的引入而一步一步扩展和改进的。

问题： 将 `a` 的所有元素的值 `*10`

```
a = [1, 2, 3, 4, 5, 6]
    |
    v (processing block)
    |
b = [10, 20, 30, 40, 50, 60]
```



## 函数返回值

函数通过 `return` 语句返回值。如果没有 `return` 语句，函数默认返回 `None`。

```python
input (a)  -----> [function (a, n, skip)]  -----> output (return)
```



## 不用函数时

```python
a = [1,2,3,4,5,6]
result = []
for element in a:
    result.append(element * 10)
print(result)  # [10, 20, 30, 40, 50, 60]
```


定义了带一个参数的函数:

```python
def list_elements_multiply(a):
    """将列表中的每个元素乘以10"""
    result = []
    for element in a:
        result.append(element * 10)
    return result
```


调用函数:

```python
a = [1,2,3,4,5,6]
li = list_elements_multiply(a)
print(li)  # [10, 20, 30, 40, 50, 60]
```



### 练习1：函数理解

```python
# 重复调用
a = [1,2,3,4,5,6]
b = list_elements_multiply(a)
c = list_elements_multiply(b)
d = list_elements_multiply(c)
print("a:", a)
print("b:", b)
print("c:", c)
print("d:", d)
```

思考：

1. 使用函数后有什么优点？
2. 本函数是否修改 a, b, c, d 的值？

### 练习2: in place 修改 list 的函数版本

[problem 02]

写一个 in place 修改列表的函数版本（直接修改原列表）：

```python
def list_elements_multiply_in_place(x):
    """直接修改列表中的每个元素（乘以10）"""
    for i in range(len(x)):
        x[i] = x[i] * 10
```

这个版本不需要 return，它返回 None。

仿照例1调用3次，结果如何？

如果也用 `y = list_elements_multiply_in_place(x)` 的形式调用，结果会如何？

### 可变/不可变参数

**可变参数**：列表、字典等可变对象作为参数时，在函数内部修改会影响原对象。

**不可变参数**：数字、字符串、元组等不可变对象作为参数时，在函数内部修改不会影响原对象。

### 作用域

**作用域**指的是变量的可见范围。在函数内部定义的变量，在函数外部无法访问。

```
def list_elements_multiply_in_place(x):
    """直接修改列表中的每个元素（乘以10）"""
    for i in range(len(x)):  # i 只在函数内有效
        x[i] = x[i] * 10
    result = "处理完成"  # result 只在函数内有效

# 调用函数后，尝试访问函数内的变量会报错
list_elements_multiply_in_place([1, 2, 3])
# print(i)      # 报错：NameError，i 未定义
# print(result) # 报错：NameError，result 未定义
```



## 将 `a` 的所有元素的值 `*n`

新增加第2个参数 n：

```python
def list_elements_multiply2(a, n):
    """将列表中的每个元素乘以n"""
    result = []
    for element in a:
        result.append(element * n)
    return result
```

### 练习3: 参数使用

[problem 03]

```python
# a = [1,2,3,4,5,6]
# 使用 list_elements_multiply2 函数，将列表 a 的所有元素乘以 5
# 请写出完整的调用代码
```



## 将 `a` 的所有元素的值 `*n` (n=10 by default)

```python
def list_elements_multiply3(a, n=10):
    """将列表中的每个元素乘以n，n默认为10"""
    result = []
    for element in a:
        result.append(element * n)
    return result
```


讨论：对于 list_elements_multiply3(a, n=10):

-   有哪几种调用方法?
-   有哪些参数可省略?
-   参数是否可以交换顺序?

### 练习4：默认参数

```python
# 对于 list_elements_multiply3(a, n=10)，以下哪些调用是正确的？
# a) list_elements_multiply3([1,2,3])
# b) list_elements_multiply3([1,2,3], 5)
# c) list_elements_multiply3(n=5, [1,2,3])
# d) list_elements_multiply3(a=[1,2,3], n=5)
```

### 练习5： 新增 skip=2 默认参数

[problem 05]

因为业务需要，对成员乘 n 的操作要跳过前 m 个 (默认为2个)，(1) 重新完成该函数的定义。

```python
def list_elements_multiply_skip(a, n=10, skip=2):
    """将列表中跳过前skip个元素后的每个元素乘以n"""
    result = []
    for i, element in enumerate(a):
        if i >= skip:
            result.append(element * n)
        else:
            result.append(element)
    return result
```

(2) 有哪些调用方法？



## 将函数保存为模块

1.  在当前目录新建文件 `my_module.py`
2.  在 `my_module.py` 文件中保存上面写好的函数，现在 `my_module.py` 就是一个模块
3.  新建一个文件 `test.py`
4.  在 `test.py` 中调用 `my_module` 中的函数

### 方法1: import

```python
import my_module
my_module.list_elements_multiply([1,2,3])
```

在 my_module.py 中再定义一个 print_hello 函数，定义一个变量 pi = 3.14，然后在 test.py 中 import 并使用它们。

### 方法2: import as

```python
import my_module as mm
mm.list_elements_multiply([1,2,3])
```



### 方法3: import specific functions

```python
from my_module import list_elements_multiply, print_hello, pi
list_elements_multiply([1,2,3])
```

### 方法4: import * (不推荐)

```python
from my_module import *
list_elements_multiply([1,2,3])
```



### 练习6：模块导入

[problem 06]

使用后两种方法使用 print_hello 函数，使用 pi 计算圆的面积。



## 综合案例练习

### 案例1：学生成绩管理系统

**场景**：你需要为一个班级的学生成绩编写处理函数

```
# 任务1：基础函数
# 编写一个函数，将学生成绩列表中的每个成绩加5分（平时分奖励）
def add_bonus(scores, bonus=5):
    # 你的代码 here
    pass

# 测试
grades = [78, 85, 92, 67, 88]
print("原始成绩:", grades)
print("加分后:", add_bonus(grades))

# 任务2：灵活的参数
# 编写一个函数，可以按不同比例调整成绩
def adjust_scores(scores, multiplier=1.0, bonus=0):
    """
    参数:
    scores - 成绩列表
    multiplier - 乘数因子 (默认1.0)
    bonus - 加分值 (默认0)
    """
    # 你的代码 here
    pass

# 测试
print("按1.1倍调整:", adjust_scores(grades, multiplier=1.1))
print("加10分:", adjust_scores(grades, bonus=10))
print("同时调整:", adjust_scores(grades, multiplier=1.05, bonus=5))

# 任务3：模块化
# 将上述函数保存到 grade_tools.py 模块中
# 然后在新的文件中导入并使用这些函数

# 在 main.py 中：
"""
import grade_tools

final_grades = [75, 82, 90, 68, 79]
processed_grades = grade_tools.adjust_scores(final_grades, multiplier=1.08, bonus=2)
print("最终成绩:", processed_grades)
"""
```



### 案例2: 进阶挑战

```
# 挑战1：增强函数功能
# 修改函数，使其能够处理不同类型的操作（加分、乘系数、设置上限等）
def advanced_adjust(scores, operation="add", value=0, max_score=100):
    """
    参数:
    operation - 操作类型: 'add', 'multiply', 'set_max'
    value - 操作数值
    max_score - 最高分限制
    """
    # 你的代码 here
    pass

# 挑战2：错误处理
# 为函数添加参数验证，确保输入的成绩在0-100之间
def safe_adjust(scores, multiplier=1.0, bonus=0):
    # 添加参数验证代码
    pass
```



## Reference

- [Python 函数 | 菜鸟教程](https://www.runoob.com/python/python-functions.html)