Python基础_03_函数

---

一、函数基础：定义与调用

函数是封装代码块的基本单位，通过“定义-调用”流程实现代码复用。

1. 函数定义

使用def关键字声明函数，语法结构如下：

def 函数名(参数列表):"""函数文档注释（可选）"""函数体代码  # 要执行的逻辑return 返回值  # 可选，无返回值时默认返回None

2. 函数调用

通过“函数名+括号”触发函数执行，括号内传入对应参数（无参数则留空）：

# 定义一个计算两数之和的函数
def add(a, b):return a + b# 调用函数，接收返回值
result = add(3, 5)
print(result)  # 输出：8

二、函数文档注释

用于说明函数功能、参数含义与返回值，方便他人理解和使用（可通过help(函数名)查看）。

规范格式（三引号包裹）

def calculate_area(radius):"""计算圆形的面积参数：radius (float/int): 圆的半径，需为非负数返回值：float: 计算得到的圆面积（π取3.14159）"""if radius < 0:raise ValueError("半径不能为负数")return 3.14159 * radius ** 2# 查看文档注释
help(calculate_area)

三、函数参数

参数是函数接收外部数据的入口，根据传递方式和特性分为以下几类：

1. 位置参数（必选）

按参数定义的顺序传入值，数量和顺序必须与函数定义一致：

def get_info(name, age):print(f"姓名：{name}，年龄：{age}")# 正确调用（按位置传参）
get_info("张三", 20)  # 输出：姓名：张三，年龄：20

2. 关键字参数

通过“参数名=值”的形式传参，可忽略参数顺序：

# 关键字参数调用（顺序可换）
get_info(age=20, name="张三")  # 输出：姓名：张三，年龄：20

3. 缺省参数（默认参数）

定义函数时给参数指定默认值，调用时可省略该参数（必须放在参数列表末尾）：

def send_msg(content, receiver="全体成员"):print(f"向{receiver}发送消息：{content}")# 省略默认参数
send_msg("开会时间调整为3点")  # 输出：向全体成员发送消息：开会时间调整为3点
# 覆盖默认参数
send_msg("请提交周报", receiver="小明")  # 输出：向小明发送消息：请提交周报

4. 不定长参数

用于接收不确定数量的参数，分为两种形式：

• *args：接收任意数量的位置参数，打包成元组
• **kwargs：接收任意数量的关键字参数，打包成字典

def print_args(*args, **kwargs):print("位置参数元组：", args)print("关键字参数字典：", kwargs)# 调用示例
print_args(1, 2, 3, name="张三", age=20)
# 输出：
# 位置参数元组： (1, 2, 3)
# 关键字参数字典： {'name': '张三', 'age': 20}

四、函数返回值

通过return语句将函数计算结果传递给调用者，支持返回单个值或多个值。

1. 返回单个值

def square(x):return x ** 2  # 返回x的平方print(square(5))  # 输出：25

2. 返回多个值

直接用逗号分隔多个返回值，函数会自动打包成元组；调用时可通过“拆包”分别接收：

def get_coords():x = 10y = 20z = 30return x, y, z  # 等价于 return (x, y, z)# 拆包接收多个返回值
a, b, c = get_coords()
print(a, b, c)  # 输出：10 20 30

五、函数嵌套

函数内部可以定义和调用其他函数，分为“嵌套定义”和“嵌套调用”。

1. 嵌套调用（函数内调用其他函数）

def add(a, b):return a + bdef calculate_total(num1, num2, num3):# 在calculate_total内部调用add函数sum1 = add(num1, num2)total = add(sum1, num3)return totalprint(calculate_total(1, 2, 3))  # 输出：6

2. 嵌套定义（函数内定义子函数）

内部子函数仅在外部函数内可见，可封装外部函数的辅助逻辑：

def outer_func(x):# 内部子函数def inner_func(y):return y ** 2  # 子函数逻辑：计算平方# 外部函数使用子函数result = inner_func(x) + xreturn resultprint(outer_func(3))  # 输出：3² + 3 = 12

六、变量作用域：局部变量与全局变量

变量的生效范围由定义位置决定，分为局部和全局两类。

类型	定义位置	生效范围	修改全局变量的方式
局部变量	函数内部	仅在当前函数内可用	无需特殊关键字
全局变量	函数外部（全局）	全局可用，函数内可读取	需在函数内用global声明

代码示例

# 全局变量
global_var = "我是全局变量"def test_scope():# 局部变量（仅函数内可用）local_var = "我是局部变量"print(local_var)  # 正常读取局部变量# 读取全局变量（无需声明）print(global_var)# 修改全局变量（必须用global声明）global global_varglobal_var = "全局变量被修改了"test_scope()
# 输出：
# 我是局部变量
# 我是全局变量print(global_var)  # 输出：全局变量被修改了
print(local_var)   # 报错：NameError（局部变量外部不可见）

七、可变类型与不可变类型（传参特性）

函数传参时，参数的修改是否影响外部变量，取决于参数的类型（可变/不可变）。

核心区别

• 不可变类型：值修改时会创建新对象，函数内修改不影响外部变量（如int、str、tuple）
• 可变类型：值修改时不创建新对象，函数内修改会影响外部变量（如list、dict、set）

代码示例

# 1. 不可变类型（int）
def modify_immutable(x):x = x + 10  # 创建新对象，不影响外部print("函数内x：", x)a = 5
modify_immutable(a)
print("函数外a：", a)  # 输出：5（未被修改）# 2. 可变类型（list）
def modify_mutable(lst):lst.append(100)  # 直接修改原列表，影响外部print("函数内列表：", lst)my_list = [1, 2, 3]
modify_mutable(my_list)
print("函数外列表：", my_list)  # 输出：[1,2,3,100]（被修改）

八、实用操作：交换变量、拆包、列表去重

1. 交换两个变量的值

无需临时变量，直接用“拆包”语法：

x = 10
y = 20# 交换值
x, y = y, xprint(x, y)  # 输出：20 10

2. 拆包（序列/字典）

将可迭代对象（如list、tuple、dict）的元素分别赋值给变量：

# 列表拆包
lst = [10, 20, 30]
a, b, c = lst
print(a, b, c)  # 输出：10 20 30# 字典拆包（默认拆key，用.values()拆value）
my_dict = {"name": "张三", "age": 20}
k1, k2 = my_dict  # 拆key
v1, v2 = my_dict.values()  # 拆value
print(k1, k2)  # 输出：name age
print(v1, v2)  # 输出：张三 20

3. 列表去重（常用方法）

利用set（集合）的“元素唯一”特性实现去重：

def remove_duplicates(lst):# 列表 → 集合（去重）→ 列表（恢复类型）return list(set(lst))original_list = [1, 2, 2, 3, 3, 3]
unique_list = remove_duplicates(original_list)
print(unique_list)  # 输出：[1,2,3]（顺序可能变化，若需保序可改用其他方法）

九、匿名函数（lambda函数）

临时定义的“一行函数”，无函数名，仅适用于简单逻辑（复杂逻辑仍用def）。

1. 定义语法

lambda 参数列表: 表达式  # 自动返回表达式结果，无需return

2. 核心应用：列表中的字典排序

结合sort()或sorted()的key参数，按字典指定字段排序：

# 待排序的字典列表（按"age"字段排序）
students = [{"name": "张三", "age": 22},{"name": "李四", "age": 19},{"name": "王五", "age": 20}
]# 用lambda函数指定排序key（按"age"升序）
students.sort(key=lambda x: x["age"])
print(students)
# 输出：
# [{"name": "李四", "age": 19}, {"name": "王五", "age": 20}, {"name": "张三", "age": 22}]