在Python编程中，函数是组织和重用代码的一种重要方式。函数可以提高代码的可读性和维护性，并且可以避免重复代码。

1. 定义函数

在Python中，函数使用def关键字定义。一个简单的函数定义包括函数名、参数列表和函数体。以下是一个基本的函数定义示例：

def greet(name):
    """
    打印问候语。
    
    参数：
    name (str): 要问候的人名。
    """
    print(f"Hello, {name}!")

在这个例子中，greet是函数名，name是参数，print语句是函数体。当你调用这个函数时，它会打印出一个问候语。

1.1 函数注释

函数注释（docstring）用于描述函数的作用、参数和返回值。它位于函数定义的第一行，使用三重引号括起来。良好的注释可以提高代码的可读性和可维护性。

1.2 函数参数

函数可以有多个参数，参数在函数名后的圆括号中定义，用逗号分隔。以下是一个接受多个参数的函数示例：

def add(a, b):
    """
    返回两个数的和。
    
    参数：
    a (int, float): 第一个数。
    b (int, float): 第二个数。
    
    返回值：
    int, float: 输入数的和。
    """
    return a + b

2. 调用函数

定义函数之后，你可以在代码的其他地方调用它。调用函数的语法是函数名后跟一对圆括号，括号内传入相应的参数。以下是调用上面greet和add函数的示例：

greet("Alice")
result = add(5, 3)
print(result)  # 输出：8

2.1 位置参数和关键字参数

在调用函数时，参数可以按位置或按名称传递。按位置传递参数称为位置参数，按名称传递参数称为关键字参数。

def introduce(name, age):
    """
    打印自我介绍。
    
    参数：
    name (str): 名字。
    age (int): 年龄。
    """
    print(f"My name is {name} and I am {age} years old.")

# 使用位置参数
introduce("Bob", 25)

# 使用关键字参数
introduce(age=30, name="Charlie")

2.2 默认参数值

你可以为函数参数指定默认值，这样在调用函数时可以省略这些参数。定义默认参数的方法是在参数名后加上等号和默认值。

def greet(name, greeting="Hello"):
    """
    打印问候语。
    
    参数：
    name (str): 要问候的人名。
    greeting (str): 问候语，默认值为"Hello"。
    """
    print(f"{greeting}, {name}!")

greet("David")  # 输出：Hello, David!
greet("Emma", "Hi")  # 输出：Hi, Emma!

3. 参数传递

Python中函数参数的传递方式有两种：按值传递和按引用传递。简单类型如整数、浮点数和字符串是按值传递的，而复杂类型如列表和字典是按引用传递的。

3.1 按值传递

按值传递意味着在函数内部修改参数的值不会影响函数外部的变量。

def modify_value(x):
    """
    尝试修改参数的值。
    
    参数：
    x (int): 一个整数。
    """
    x = 10
    print(f"Inside function: x = {x}")

value = 5
modify_value(value)
print(f"Outside function: value = {value}")  # 输出：Outside function: value = 5

3.2 按引用传递

按引用传递意味着在函数内部修改参数的值会影响函数外部的变量。

def modify_list(lst):
    """
    向列表中添加元素。
    
    参数：
    lst (list): 一个列表。
    """
    lst.append(4)
    print(f"Inside function: lst = {lst}")

my_list = [1, 2, 3]
modify_list(my_list)
print(f"Outside function: my_list = {my_list}")  # 输出：Outside function: my_list = [1, 2, 3, 4]

4. 作用域

作用域指的是变量在程序中的可见性和生命周期。Python有两种主要的作用域：全局作用域和局部作用域。

4.1 全局作用域

在全局作用域中定义的变量在整个程序中都可以访问。通常在模块级别（文件级别）定义的变量是全局变量。

global_var = "I am global"

def print_global():
    """
    打印全局变量。
    """
    print(global_var)

print_global()  # 输出：I am global

4.2 局部作用域

在函数内部定义的变量只能在函数内部访问，这些变量称为局部变量。

def print_local():
    """
    定义并打印局部变量。
    """
    local_var = "I am local"
    print(local_var)

print_local()  # 输出：I am local
# print(local_var)  # 这行代码会报错，因为local_var在函数外不可见

4.3 global 关键字

如果需要在函数内部修改全局变量，可以使用global关键字声明该变量。

counter = 0

def increment():
    """
    增加全局变量counter的值。
    """
    global counter
    counter += 1

increment()
print(counter)  # 输出：1

4.4 nonlocal 关键字

在嵌套函数中，如果需要修改外部函数的变量，可以使用nonlocal关键字。

def outer():
    """
    外部函数，定义变量。
    """
    x = "outer"
    
    def inner():
        """
        内部函数，修改外部函数变量。
        """
        nonlocal x
        x = "inner"
    
    inner()
    print(x)

outer()  # 输出：inner

5. 递归函数

递归函数是指在函数内部调用自身的函数。递归通常用于解决分治问题，例如计算阶乘或斐波那契数列。

5.1 计算阶乘

计算阶乘的递归函数示例：

def factorial(n):
    """
    计算n的阶乘。
    
    参数：
    n (int): 一个整数。
    
    返回值：
    int: n的阶乘。
    """
    if n == 0:
        return 1
    else:
        return n * factorial(n - 1)

print(factorial(5))  # 输出：120

5.2 计算斐波那契数列

计算斐波那契数列的递归函数示例：

def fibonacci(n):
    """
    计算斐波那契数列的第n个数。
    
    参数：
    n (int): 一个整数。
    
    返回值：
    int: 斐波那契数列的第n个数。
    """
    if n <= 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(6))  # 输出：8

6. 高阶函数

高阶函数是指接受另一个函数作为参数或返回另一个函数的函数。在Python中，函数是一等公民，这意味着函数可以作为参数传递，也可以作为返回值返回。

6.1 函数作为参数

以下是一个接受函数作为参数的示例：

def apply_function(func, value):
    """
    对给定值应用给定函数。
    
    参数：
    func (function): 一个函数。
    value (any): 一个值。
    
    返回值：
    any: 应用函数后的值。
    """
    return func(value)

def square(x):
    """
    计算x的平方。
    
    参数：
    x (int, float): 一个数。
    
    返回值：
    int, float: x的平方。
    """
    return x * x

print(apply_function(square, 5))  # 输出：25

6.2 函数作为返回值

以下是一个返回函数的示例：

def power(exponent):
    """
    返回一个计算幂的函数。
    
    参数：
    exponent (int): 幂指数。
    
    返回值：
    function: 一个计算幂的函数。
    """
    def inner(base):
        """
        计算base的exponent次幂。
        
        参数：
        base (int, float): 底数。
        
        返回值：
        int, float: base的exponent次幂。
        """
        return base ** exponent
    
    return inner

square = power(2)
print(square(3))  # 输出：9

7. lambda 表达式

lambda 表达式是用于创建小型匿名函数的简洁方式。lambda 函数可以有任意数量的参数，但只能有一个表达式。

# 定义一个 lambda 函数
square = lambda x: x * x

# 使用 lambda 函数
print(square(4))  # 输出：16

# 作为参数传递给高阶函数
print(apply_function(lambda x: x + 1, 7))  # 输出：8

8. 内置高阶函数

Python 提供了一些内置的高阶函数，如map、filter和reduce，它们可以用于函数式编程。

8.1 map 函数

map函数用于对可迭代对象中的每个元素应用一个函数，并返回一个迭代器。

numbers = [1, 2, 3, 4]
squared_numbers = map(lambda x: x * x, numbers)
print(list(squared_numbers))  # 输出：[1, 4, 9, 16]

8.2 filter 函数

filter函数用于过滤可迭代对象中的元素，保留满足条件的元素。

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(lambda x: x % 2 == 0, numbers)
print(list(even_numbers))  # 输出：[2, 4, 6]

8.3 reduce 函数

reduce函数用于对可迭代对象中的元素进行累积计算。它在functools模块中定义，需要手动导入。

from functools import reduce

numbers = [1, 2, 3, 4]
sum = reduce(lambda x, y: x + y, numbers)
print(sum)  # 输出：10

上面介绍了Python函数的定义和调用，包括位置参数、关键字参数和默认参数值。还讨论了参数传递、作用域和递归函数，高阶函数和lambda表达式，展示了如何在Python中使用函数进行更高级的编程操作。