跳到主要内容

Python 函数

函数是组织代码的基本单元，可以提高代码的复用性和可读性。

函数定义​

基本语法​

def function_name(parameters):
    """函数文档字符串"""
    # 函数体
    return result  # 返回值

示例​

def greet():
    """问候函数"""
    print("你好，欢迎学习 Python！")

# 调用函数
greet()

函数参数​

位置参数​

def add(a, b):
    return a + b

result = add(3, 5)  # result = 8

默认参数​

def greet(name, greeting="你好"):
    print(f"{greeting}，{name}！")

greet("张三")           # 你好，张三！
greet("李四", "欢迎")  # 欢迎，李四！

关键字参数​

def person(name, age, city):
    print(f"姓名：{name}")
    print(f"年龄：{age}")
    print(f"城市：{city}")

# 使用关键字参数
person(name="张三", age=20, city="北京")
person(city="上海", name="李四", age=25)

不定长参数​

*args - 接收任意数量的位置参数​

def sum_all(*args):
    total = 0
    for num in args:
        total += num
    return total

print(sum_all(1, 2, 3))       # 6
print(sum_all(1, 2, 3, 4, 5)) # 15

**kwargs - 接收任意数量的关键字参数​

def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

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

参数组合使用​

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

func(1, 2, 3, 4, 5, name="张三", age=20)
# a=1, b=2, c=3
# args=(4, 5)
# kwargs={'name': '张三', 'age': 20}

函数返回值​

return 语句​

def add(a, b):
    return a + b

result = add(3, 5)  # result = 8

返回多个值​

def get_person():
    name = "张三"
    age = 20
    city = "北京"
    return name, age, city

person = get_person()
print(person)  # ('张三', 20, '北京')

# 也可以用多个变量接收
name, age, city = get_person()

无返回值​

def print_hello():
    print("Hello")

result = print_hello()  # result = None

变量作用域​

局部变量​

在函数内部定义的变量，只能在函数内部使用：

def test():
    x = 10  # 局部变量
    print(x)

test()  # 10
# print(x)  # 错误：x 未定义

全局变量​

在函数外部定义的变量，可以在整个文件中使用：

x = 10  # 全局变量

def test():
    print(x)  # 可以访问全局变量

test()  # 10

使用 global 关键字​

在函数内部修改全局变量：

x = 10

def test():
    global x  # 声明使用全局变量
    x = 20

test()
print(x)  # 20

nonlocal 关键字​

在嵌套函数中修改外层函数的变量：

def outer():
    x = 10
    
    def inner():
        nonlocal x
        x = 20
    
    inner()
    print(x)  # 20

outer()

匿名函数（lambda）​

lambda 函数是简单的匿名函数：

# 基本语法
lambda parameters: expression

# 示例
square = lambda x: x ** 2
print(square(5))  # 25

# 多参数
add = lambda a, b: a + b
print(add(3, 5))  # 8

lambda 与内置函数结合​

# 与 map() 配合
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# 与 filter() 配合
numbers = [1, 2, 3, 4, 5, 6]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4, 6]

# 与 sorted() 配合
pairs = [(1, 'one'), (3, 'three'), (2, 'two')]
sorted_pairs = sorted(pairs, key=lambda x: x[0])
print(sorted_pairs)  # [(1, 'one'), (2, 'two'), (3, 'three')]

递归函数​

函数调用自身：

# 阶乘
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))  # 120

# 斐波那契数列
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55

函数注解​

为函数参数和返回值添加元数据：

def func(a: int, b: str) -> str:
    """带有类型注解的函数"""
    return f"{a} - {b}"

# 注解不会强制执行，仅作为提示
print(func(1, "hello"))

高阶函数​

接受函数作为参数或返回函数的函数：

def apply(func, value):
    """高阶函数：接受另一个函数作为参数"""
    return func(value)

def double(x):
    return x * 2

result = apply(double, 5)  # 10

内置函数​

Python 提供了许多内置函数：

# 数值相关
abs(-5)           # 5 - 绝对值
max([1, 2, 3])    # 3 - 最大值
min([1, 2, 3])    # 1 - 最小值
pow(2, 3)         # 8 - 幂运算
round(3.7)        # 4 - 四舍五入
sum([1, 2, 3])    # 6 - 求和

# 类型转换
int("10")         # 10
float("3.14")     # 3.14
str(123)          # "123"
bool(1)           # True

# 其他
len("hello")      # 5 - 长度
type(123)         # <class 'int'> - 类型
range(5)          # range(0, 5)
list(range(5))    # [0, 1, 2, 3, 4]

小结​

本章我们学习了：

  1. 函数的定义和调用
  2. 函数参数（位置参数、默认参数、关键字参数、不定长参数）
  3. 函数返回值
  4. 变量作用域（局部变量、全局变量）
  5. 匿名函数 lambda
  6. 递归函数
  7. 函数注解
  8. 高阶函数
  9. 内置函数

练习​

  1. 编写一个函数，计算两个数的最大公约数
  2. 编写一个函数，判断一个字符串是否是回文
  3. 编写一个函数，接受任意数量的数字，返回最大值和最小值
  4. 使用递归实现汉诺塔游戏