四、Python的程序结构与函数

4.4 函数

函数能将代码划分为若干模块，每一个模块可以相对独立的实现某一个功能，函数有两个主要功能，分别是降低编程难度和实现代码复用，函数是一种功能抽象，复用它可以将一个复杂的大问题分解为一系列简单的小问题，小问题再分解成更小的问题，是一种分而治之的思想运用。

4.4.1 函数定义

函数的定义即函数功能的实现过程，包含函数头与函数体两部分。使用def关键字定义函数，后跟函数名、参数和冒号。函数体缩进。
语法格式如下：

def 函数名(参数1,参数2):
	函数体
	return 返回值列表
其中，关键要点包括：
def:关键字，标志着函数的开始。
函数名：函数的唯一标识。
参数：参数列表中的参数是形式参数，形参只在函数体中有效。
形文档字符串：在函数体开始的第一个语句通常是一个字符串，用于描述函数的作用、参数、返回值等信息。
冒号：用于标记函数体的开始。
函数体：函数体包含了实现函数功能的代码块，由一行或多行代码组成。
返回值：标志函数的结束，将返回值赋给函数的调用者，可选的返回一个值，如果没有return，函数将返回none。

4.4.2 函数调用

函数被定义好之后不会立即执行，只有被程序调用时才会执行。
语法格式：
函数名（实参）
调用时，参数列表中给出实际要传入函数内部的参数，这类参数称为实际参数，即实参，实参可以是变量、常量、表达式、函数等。

4.4.3 参数传递

Python中函数的参数传递是指实参传递给形参的过程。python中函数支持以多种方式传递参数，包括位置传递，关键字传递，默认值传递，包裹传递，解包裹传递以及混合传递。

## 1. 位置传递（Positional Arguments）

位置传递是最基本的参数传递方式，参数按照函数定义时的位置顺序依次传递给函数。

**示例：**

```python
def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}")

greet("John", "Doe")  # Hello, John Doe
markdown2. 关键字传递（Keyword Arguments）关键字传递允许调用者明确指定参数的名称和值，这样就不必关心参数的顺序。示例：def greet(first_name, last_name):
    print(f"Hello, {first_name} {last_name}")

greet(last_name="Doe", first_name="John")  # Hello, John Doe
python3. 默认值传递（Default Argument Values）在函数定义时，可以为参数设置默认值。当调用函数时如果没有传递该参数，则使用默认值。示例：def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}")

greet("John")  # Hello, John
greet("Jane", greeting="Hi")  # Hi, Jane
python4. 包裹传递（Variable-Length Non-Keyword Arguments, *args）使用星号(*)前缀的参数可以收集所有额外的位置参数，并将它们作为元组传递给函数。示例：def sum_all(*numbers):
    return sum(numbers)

print(sum_all(1, 2, 3, 4))  # 10
python5. 解包裹传递（Unpacking, * for lists/tuples and ** for dictionaries）解包裹允许将一个列表、元组或字典解包成多个参数。示例：def greet(name, greeting):
    print(f"{greeting}, {name}")

args = ["John", "Hello"]
greet(*args)  # Hello, John

kwargs = {"name": "Jane", "greeting": "Hi"}
greet(**kwargs)  # Hi, Jane
python6. 可变关键字参数传递（Variable-Length Keyword Arguments, **kwargs）双星号(**)前缀的参数可以收集所有额外的关键字参数，并将它们作为字典传递给函数。示例：def describe_person(name, **details):
    print(f"{name}:")
    for key, value in details.items():
        print(f"  {key}: {value}")

describe_person("Alice", age=30, job="Engineer")  # Alice:
                                                  #   age: 30
                                                  #   job: Engineer
python7. 混合传递函数可以同时接受位置参数、关键字参数、默认值参数、可变参数等。示例：def describe_person(name, age, job=None, **details):
    print(f"{name} is a {age}-year-old {job or 'person'}:")
    for key, value in details.items():
        print(f"  {key}: {value}")

describe_person("Bob", 25, job="Developer", city="New York", hobby="Coding")

4.4.4 函数返回值（Return Values）

在Python中，函数可以通过return󠁪语句来返回一个或多个值。如果函数没有显式地返回任何值，则默认返回None󠁪。返回值可以是任何数据类型，包括基本类型（如整数、字符串）、复杂类型（如列表、字典）甚至是自定义对象。示例：

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

result = add(3, 4)
print(result)  # 输出：7

def get_user_info(name, age):
    return {
        "name": name,
        "age": age
    }

user = get_user_info("Alice", 30)
print(user)  # 输出：{'name': 'Alice', 'age': 30}

4.4.5 python函数作用域（Scope）

函数作用域决定了变量的可见性和生命周期。Python中有以下几种作用域：1. 局部作用域（Local Scope）：在函数内部定义的变量仅在该函数内部可见。函数执行完毕后，这些变量会被销毁。

def my_function():
    local_var = 5
    print(local_var)  # 可以访问local_var

my_function()  # 输出：5
print(local_var)  # 错误：NameError: name 'local_var' is not defined
python1. 全局作用域（Global Scope）：在函数外部定义的变量拥有全局作用域，整个文件内都可以访问，除非在函数内部被重新定义为局部变量。global_var = 10

def access_global():
    print(global_var)

access_global()  # 输出：10

def modify_global():
    global global_var  # 使用global关键字声明使用全局变量
    global_var = 20

modify_global()
print(global_var)  # 输出：20
python1. 内置作用域（Built-in Scope）：包含Python内置的名称（如len󠁪, range󠁪, str󠁪等），这些名称在任何地方都可以直接访问。2. 非局部作用域（Non-local Scope/Enclosing Scope）：当一个函数嵌套在另一个函数内时，外层函数内的变量对内层函数而言是非局部变量。使用nonlocal󠁪关键字可以在内层函数中修改外层函数的变量。def outer():
    enclosed_var = 100
    
    def inner():
        nonlocal enclosed_var
        enclosed_var = 200
        print(enclosed_var)
    
    inner()
    print(enclosed_var)  # 输出也会是200，因为inner函数修改了enclosed_var

outer()

python理解函数作用域对于编写清晰、可维护的代码至关重要，它帮助我们控制变量的可见范围，避免命名冲突。

4.5 匿名函数（Lambda Functions）

匿名函数，通常被称为lambda函数，在Python中是一种简洁的方式用于定义小型、一次性使用的函数。这种函数不需要使用def󠁪关键字来定义，而是使用lambda󠁪关键字。lambda函数的主要用途是在需要小函数的地方，特别是在作为参数传递给高阶函数时，如map()󠁪, filter()󠁪, sorted()󠁪等。

语法：lambda arguments: expression
python示例：# 使用lambda函数进行平方计算
square = lambda x: x ** 2
print(square(5))  # 输出：25

使用lambda函数对列表进行排序

students = [("Alice", 28), ("Bob", 22), ("Charlie", 30)]
students.sort(key=lambda student: student[1])
print(students)  # 输出：[('Bob', 22), ('Alice', 28), ('Charlie', 30)]

4.6 模块化编程

模块化编程是一种将程序分解成独立部分的方法，每个部分负责特定的功能。在Python中，模块就是包含Python定义和语句的文件。通过将代码组织成模块，可以提高代码的可读性、可重用性和可维护性。

创建模块： 创建一个.py󠁪文件即为创建一个模块，例如math_operations.py󠁪。模块内容示例：# math_operations.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b
python导入模块： 使用import󠁪语句可以导入模块，然后调用其中的函数。导入示例：import math_operations

result = math_operations.add(5, 3)
print(result)  # 输出：8

result = math_operations.subtract(10, 4)
print(result)  # 输出：6
python从模块导入特定函数： 使用from ... import ...󠁪语句可以直接导入模块中的特定函数，而无需每次调用时都加上模块名前缀。导入特定函数示例：from math_operations import add, subtract

result = add(7, 2)
print(result)  # 输出：9

result = subtract(15, 5)
print(result)  # 输出：10
python使用as关键字给模块或函数起别名： 可以使用as󠁪关键字给导入的模块或函数起别名，简化调用过程。别名示例：import math_operations as mo

result = mo.add(8, 2)
print(result)  # 输出：10

from math_operations import add as a, subtract as s

result = a(9, 3)
print(result)  # 输出：12

result = s(18, 8)
print(result)  # 输出：10

python模块化编程是Python编程中的一项重要技能，它有助于保持代码的整洁和高效，同时也便于团队协作和代码复用。