一、什么是函数?
函数(Function)是一段具有独立功能、可以被重复调用的程序代码。
它将一组相关操作封装起来,通过明确的输入和输出接口,为程序提供模块化的执行能力。
例如:
def add(a, b):
return a + b
result = add(10, 20)
print(result)
这里定义了一个 add 函数,用于计算两个数的和。
函数具有以下几个基本特征:
- 封装性:将一组操作组织为独立的逻辑单元。
- 复用性:同一个函数可以在不同位置重复调用。
- 参数化:通过参数接收不同输入。
- 返回值:通过返回机制向调用者提供计算结果。
- 抽象性:调用者不需要了解函数内部的具体实现。
函数不仅是代码复用的工具,也是程序控制流、模块边界和软件架构的重要基础。
二、函数的基本组成
一个典型的函数通常由函数名称、参数列表、函数体和返回值组成。
def calculate_area(width, height):
area = width * height
return area
各部分含义:
| 组成部分 | 示例 | 作用 |
|---|---|---|
| 函数定义关键字 | def |
声明一个函数 |
| 函数名称 | calculate_area |
标识函数 |
| 参数列表 | width, height |
接收调用者传入的数据 |
| 函数体 | area = width * height |
执行具体逻辑 |
| 返回语句 | return area |
将结果返回调用者 |
不同编程语言的函数定义语法有所区别,但核心结构基本一致。
1. Python 函数定义
def add(a, b):
return a + b
2. Java 函数定义
在 Java 中,通常将函数称为方法(Method),方法必须定义在类或接口等类型结构中。
public class Calculator {
public int add(int a, int b) {
return a + b;
}
}
3. JavaScript 函数定义
function add(a, b) {
return a + b;
}
JavaScript 还支持函数表达式和箭头函数:
const add = function(a, b) {
return a + b;
};
const multiply = (a, b) => a * b;
4. C 语言函数定义
int add(int a, int b) {
return a + b;
}
C 语言函数需要明确指定返回类型和参数类型。
三、函数定义与函数调用
函数定义和函数调用是两个不同的概念。
- 函数定义:声明函数的名称、参数、返回类型及具体实现。
- 函数调用:通过函数名称或函数引用,触发函数体执行。
1. 函数定义
def greet(name):
print("Hello,", name)
执行函数定义语句时,Python 会创建相应的函数对象,并将其绑定到名称 greet。
此时,函数体中的代码通常还没有执行。
2. 函数调用
greet("Alice")
调用函数后,程序才会执行函数体。
3. 定义与调用的执行关系
flowchart TB
A["编写函数定义"] --> B["创建函数或声明函数"]
B --> C["程序执行到调用位置"]
C --> D["准备实参"]
D --> E["进入函数执行"]
E --> F["执行函数体"]
F --> G["返回结果或结束执行"]
G --> H["调用者继续执行"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意,函数定义的执行时机与语言有关。
例如:
- Python 在执行
def语句时创建函数对象。 - JavaScript 会根据声明类型和执行上下文处理函数声明与函数表达式。
- C 和 Java 通常在编译阶段完成函数或方法的相关处理,运行时执行调用指令。
因此,不能将所有语言的函数定义都理解为运行时才创建函数。
四、参数与实参
参数是函数接收外部数据的接口。
在函数定义和调用过程中,需要区分形式参数(Parameter)与实际参数(Argument)。
1. 形式参数(Parameter)
形式参数是在函数定义中声明的变量。
def add(a, b):
return a + b
这里的 a 和 b 就是形式参数。
它们用于描述函数需要接收哪些数据。
2. 实际参数(Argument)
实际参数是在调用函数时传入的具体值或表达式。
result = add(10, 20)
这里的 10 和 20 就是实际参数。
3. 形式参数与实际参数的区别
| 对比维度 | 形式参数 | 实际参数 |
|---|---|---|
| 英文 | Parameter | Argument |
| 出现位置 | 函数定义 | 函数调用 |
| 本质 | 参数变量 | 传入的数据或表达式 |
| 作用 | 描述函数输入接口 | 提供具体输入 |
4. 参数传递过程
flowchart TB
A["调用者准备实际参数"] --> B["执行函数调用"]
B --> C["按照语言规则进行参数绑定或传递"]
C --> D["函数获得对应参数"]
D --> E["使用参数执行函数体"]
E --> F["产生计算结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
参数绑定和底层参数传递并不是同一个层次的概念。
参数绑定属于语言语义,决定实参如何对应到形式参数;底层参数传递则由编译器、运行时和 ABI 决定,可能使用寄存器、栈或其他机制。
五、函数参数的常见形式
不同语言提供了多种参数形式,以满足不同的函数调用需求。
1. 位置参数(Positional Arguments)
根据参数在定义中的位置进行匹配。
def introduce(name, age):
print(name, age)
introduce("Alice", 25)
对应关系:
"Alice"对应name。25对应age。
位置参数要求调用顺序与参数定义顺序保持一致。
2. 关键字参数(Keyword Arguments)
通过参数名称指定传入值。
def introduce(name, age):
print(name, age)
introduce(age=25, name="Alice")
关键字参数不依赖位置顺序,但必须符合语言规定的参数绑定规则。
Python 中,位置参数和关键字参数可以组合使用:
introduce("Alice", age=25)
3. 默认参数(Default Arguments)
在函数定义时为参数指定默认值。
def greet(name, message="Hello"):
print(message, name)
greet("Alice")
greet("Bob", "Welcome")
输出:
Hello Alice
Welcome Bob
当调用者没有提供 message 时,函数使用默认值。
Python 默认参数的易错点:
默认参数表达式通常在函数定义时求值,而不是每次调用时重新求值。
例如:
def append_item(item, items=[]):
items.append(item)
return items
print(append_item(1))
print(append_item(2))
结果:
[1]
[1, 2]
原因是默认列表对象被多次调用共享。
更安全的写法:
def append_item(item, items=None):
if items is None:
items = []
items.append(item)
return items
4. 可变数量参数(Variadic Arguments)
当函数需要接收数量不固定的参数时,可以使用可变参数。
Python:
def add_all(*numbers):
return sum(numbers)
print(add_all(1, 2, 3))
print(add_all(1, 2, 3, 4, 5))
*numbers 会将位置参数收集为元组。
Python 还支持 **kwargs,用于收集关键字参数:
def show_info(**kwargs):
for key, value in kwargs.items():
print(key, value)
show_info(name="Alice", age=25)
kwargs 会收集为字典。
5. 参数形式对比
| 参数类型 | 作用 | Python 示例 |
|---|---|---|
| 位置参数 | 按位置匹配 | func(10, 20) |
| 关键字参数 | 按名称匹配 | func(a=10) |
| 默认参数 | 提供默认值 | def func(a=10) |
| 可变位置参数 | 接收多个位置参数 | *args |
| 可变关键字参数 | 接收多个关键字参数 | **kwargs |
不同语言的参数机制并不完全相同。例如,Java 使用重载和可变参数,C 使用固定参数列表或特定的可变参数机制。
六、值传递与引用传递
参数传递方式是函数设计中非常容易混淆的概念。
常见说法包括:
- 值传递(Pass by Value)。
- 引用传递(Pass by Reference)。
理解这两个概念,需要关注函数调用时,调用者与被调用者之间究竟共享什么。
1. 值传递(Pass by Value)
值传递是指函数接收实参值的副本。
函数内部修改参数变量,不会直接改变调用者的原始变量。
C 语言示例:
#include <stdio.h>
void change(int x) {
x = 100;
}
int main() {
int a = 10;
change(a);
printf("%d\n", a);
return 0;
}
输出:
10
原因:
a的值为 10。- 调用
change(a)时,将值复制给参数x。 - 修改
x不会影响a。
2. 引用传递(Pass by Reference)
引用传递意味着函数参数直接引用调用者提供的变量。
在支持引用参数的语言中,函数可以通过参数修改调用者的变量。
C++ 示例:
#include <iostream>
using namespace std;
void change(int& x) {
x = 100;
}
int main() {
int a = 10;
change(a);
cout << a << endl;
}
输出:
100
这里的 int& x 是引用参数,x 与调用者的变量 a 指向同一个对象。
3. 指针传递与引用传递的区别
C 语言没有原生的引用参数语法,但可以通过指针实现对调用者数据的间接修改。
void change(int *x) {
*x = 100;
}
int main() {
int a = 10;
change(&a);
}
这里仍然是值传递:传递的是指针值的副本。
但指针副本与原指针指向同一块内存,因此可以通过解引用修改原始变量。
这说明:
值传递不代表一定无法修改调用者的数据,关键在于传递的值是否包含对共享对象的访问能力。
4. Python 的参数传递机制
Python 通常被描述为对象引用传递(Call by Sharing),也称为对象共享传递。
调用函数时,参数名称绑定到传入的对象。
def change(items):
items.append(100)
data = [1, 2, 3]
change(data)
print(data)
输出:
[1, 2, 3, 100]
函数通过参数访问同一个列表对象,因此列表内容发生变化。
但如果重新绑定参数:
def change(items):
items = [100, 200]
data = [1, 2, 3]
change(data)
print(data)
输出仍然是:
[1, 2, 3]
原因是函数内部只是让局部名称 items 指向另一个列表,并没有改变调用者名称 data 的绑定关系。
5. 不同语言的参数传递机制
| 语言 | 常见参数传递机制 |
|---|---|
| C | 值传递,包括指针值 |
| C++ | 值传递、引用参数 |
| Java | 值传递,包括对象引用值 |
| Python | 对象共享传递 |
| JavaScript | 值传递,包括对象引用值 |
| Go | 值传递,包括指针值 |
| Rust | 值传递、借用与可变借用 |
尤其需要注意:
Java 并不支持传统意义上的引用传递。对象参数传递的是对象引用值的副本,因此可以修改对象内容,但不能通过重新赋值参数改变调用者的引用变量。
七、函数返回值(Return Value)
返回值是函数向调用者输出计算结果的机制。
通过 return 等语言结构,可以结束当前函数执行,并将结果交还给调用者。
1. 返回单个值
def multiply(a, b):
return a * b
result = multiply(3, 4)
print(result)
返回结果:
12
2. 无返回值函数
部分函数只负责执行操作,不需要返回有意义的结果。
Python:
def log_message(message):
print(message)
Java:
public void logMessage(String message) {
System.out.println(message);
}
C:
void log_message(const char *message) {
printf("%s\n", message);
}
不同语言对无返回值函数的表达方式不同。
Python 函数如果没有显式执行 return,会隐式返回 None。
3. 返回多个值
Python 支持通过元组返回多个结果:
def calculate(a, b):
return a + b, a - b
sum_value, diff_value = calculate(10, 5)
本质上,函数返回的是一个元组,再通过解包获得其中的值。
其他语言可以使用结构体、对象、元组或多个输出参数实现类似功能。
4. return 的执行特点
return 通常具有两个作用:
- 结束当前函数的执行。
- 将返回结果交还给调用者。
例如:
def check_number(n):
if n < 0:
return "negative"
return "non-negative"
当条件成立并执行第一个 return 后,当前函数不会继续执行后面的语句。
5. 函数返回过程
flowchart TB
A["调用者执行函数调用"] --> B["进入函数体"]
B --> C["执行计算逻辑"]
C --> D{"是否执行返回语句"}
D -->|"是"| E["准备返回值"]
D -->|"否"| F["执行剩余函数逻辑"]
F --> D
E --> G["结束当前函数"]
G --> H["返回调用者"]
H --> I["接收或处理返回值"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
八、函数调用的底层执行机制
函数调用不仅是源码层面的语法操作,最终还需要通过编译器、运行时和 CPU 完成实际执行。
一次典型的函数调用涉及:
- 参数准备。
- 参数传递。
- 返回地址保存。
- 栈帧建立。
- 函数体执行。
- 返回值准备。
- 栈帧恢复。
- 控制流返回。
1. 函数调用与调用栈
调用栈(Call Stack)是程序运行时用于管理函数调用关系的重要数据结构。
当函数调用另一个函数时,通常需要保存当前函数的执行状态,并为被调用函数建立相应的执行环境。
例如:
def first():
second()
def second():
third()
def third():
print("Hello")
first()
函数调用关系:
flowchart TB
A["first()"] --> B["second()"]
B --> C["third()"]
C --> D["print()"]
D --> E["返回 third()"]
E --> F["返回 second()"]
F --> G["返回 first()"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
调用栈遵循后进先出(LIFO)原则。
函数调用时建立新的调用上下文,函数返回时销毁或退出当前调用上下文。
2. 栈帧(Stack Frame)
每次函数调用通常会关联一个栈帧。
栈帧用于保存函数执行所需的部分状态信息。
常见内容包括:
- 返回地址。
- 局部变量。
- 参数或参数相关信息。
- 保存的寄存器。
- 临时计算数据。
- 栈对齐填充空间。
典型栈帧可以抽象表示为:
高地址
┌────────────────────────┐
│ 调用者栈帧 │
├────────────────────────┤
│ 返回地址 │
├────────────────────────┤
│ 保存的寄存器 │
├────────────────────────┤
│ 局部变量 │
├────────────────────────┤
│ 临时计算空间 │
└────────────────────────┘
低地址
这只是概念性布局。
实际布局取决于 CPU 架构、ABI、编译器优化和运行时实现。
例如:
- 参数可能通过寄存器传递。
- 局部变量可能直接分配在寄存器中。
- 编译器可能省略帧指针。
- 内联优化可能消除实际函数调用。
3. 函数调用的机器级过程
以 x86-64 为例,普通函数调用通常涉及 call 和 ret 指令。
call:保存返回地址,并转移控制流到目标函数。ret:从栈中恢复返回地址,并转移回调用者。
概念过程:
flowchart TB
A["执行调用指令 call"] --> B["保存返回地址"]
B --> C["跳转到目标函数"]
C --> D["执行函数逻辑"]
D --> E["准备返回值"]
E --> F["执行返回指令 ret"]
F --> G["恢复返回地址"]
G --> H["继续执行调用者代码"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意,call 和 ret 是 x86 指令集中的具体机制,并不是所有 CPU 架构都采用相同的函数调用指令。