函数和模式化——python

一、模块和包

        将一段代码保存为应该扩展名为.py 的文件，该文件就是模块。Python中的模块分为三种，分别为：内置模块、第三方模块和自定义模块。

• 内置模块和第三方模块又称为库
• 内置模块，有 python 解释器自带，不用单独安装
• 第三方模块，需要下载后手动安装
• 如果内置模块和第三方模块没有需要的功能，就需要用户自己编写程序，将程序保存为.py 文件，即是自定义模块。

无论哪种模块都需要使用 import 调用后，才能在程序中调用其中的功能函数。

       

        将功能近似的、关联较强的模块组织起来，形成一个目录，叫做包。

python中的包是模块包，文件名。包括：

• 一组模块
• _init_.py 文件
• 支持多层嵌套
• .py 程序文件中可以直接定义一些变量，函数和类
• 使用时，通过import 导入，如： import math

他们的关系如下：

        包——>  模块 ——> 函数

二、函数

1、函数的定义函数的语法格式如下：       

def 函数名（ [ 次数1，参数2，…，参数n ] ）：

                语句块

                [ return [ 返回值1，返回值2，…，返回值n] ]

2、函数的定义和调用

（1）def 为python保留字，用于定义函数，函数名的命名规则和变量一致；

（2）括号中是函数的参数，参数可以为空，此时，括号（）不能省略，函数参数也可以是多个，多个参数之间有英文逗号隔开；

（3）语句块是函数体，可以对函数进行调用，完成函数的主要功能；

（4）retrun 是函数的返回保留字，当函数没有返回值时，return 保留字可以省略，函数有多个返回值时，在return 保留字后面，将多个返回值以英文逗号隔开；

#无返回值时省略return
def greet(name):
    print(f"Hello, {name}!")
result = greet("Alice")  # 输出: Hello, Alice!
print(result)            # 输出: None


#单返回值
def add(a, b):
    return a + b
sum_result = add(3, 5)  # sum_result = 8


#多返回值
def calculate(a, b):
    add = a + b
    sub = a - b
    return add, sub  # 实际返回元组 (add, sub)

result = calculate(10, 5)
print(result)        # 输出: (15, 5)

# 解包返回值
sum_result, diff_result = calculate(10, 5)
print(sum_result)    # 输出: 15
print(diff_result)   # 输出: 5

这里的解包返回值，大家不懂的话不要害怕，我在最后做了补充。

（5）函数的类型和函数的返回值类型相同，当返回值是多个时，函数的返回值是元组类型。

• 单返回值类型：若函数返回单个值（如 int），则直接标注为对应类型。

def get_number() -> int:
    return 42

• 多返回值类型：若函数返回多个值（如 a, b），Python 会将其转换为元组。此时返回值类型应标注为 tuple[类型1, 类型2, ...]。

def calculate(a: int, b: int) -> tuple[int, int]:
    return a + b, a - b  # 实际返回 (int, int) 类型的元组

三、函数的参数

1、形参与实参

• 函数定义时，圆括号内参数列表的参数，不代表具体的数据，称为形参;
• 函数调用时，将具体的数据传递给形式参数，此时的参数称为实参。
• 根据参数的不同数据类型，将实参的值或者引用传递给形参。
• 当参数类型为不可变数据类型时，在函数内部直接修改形参的值不会影响实参;
• 但当参数类型为可变数据类型时，在函数内部使用下标或其他方式为其增加、删除元素或修改元素值时，修改后的结果是可以传递到函数之外的，即实参也会得到相应的修改。

2、必备参数、默认参数、可变参数和关键字参数

• 函数调用时，必须传递的参数，称为必备参数，也称必选参数；
• 函数定义时，设置了默认值的参数函数调用时，可以传递实参，也可以不传递参数，不传递时，参数取定义时的默认值，这种参数，称为默认参数，也称可选参数。
• 需要注意的是，必备参数必须在前面定义，其他参数在后面定义。

3、参数传递

• 在函数调用参数传递时，按位置形参和实参一一对应传递称为位置传递；
• 在函数调用参数传递时，按照参数的名称显式的传递，称为名称传递。

        按位置传递，不需要给出参数的名称，但形参和实参的位置相同、类型相同，否则容易出错;按名称显式的传递参数，则不关心参数的前后顺序，在参数较多时，不容易混淆。

4、全局变量与局部变量

• 在函数外部定义的变量，称为全局变量;在函数内部定义的变量称为局部变量。
• 全局变量的生命周期是程序的整个运行周期，只有程序被关闭后全局变量才会被销毁并释放内存空间，因此，全局变量在整个程序中，都可以使用；
• 局部变量的生命周期是函数调用时间，函数调用结束返回后，局部变量就销毁并释放内存空间，因此局部变量的作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的。

5、匿名函数

        当函数一次性使用，函数体语句较少，如只有一个表达式，为了节省内存中变量定义空间就不需要定义函数名，此时，可以定义匿名函数。名函数的语法格式是:
 

        函数名 =lambda」参数]:返回值

              
        匿名函数可以有0个或多个参数，但必须有返回值。匿名函数的调用和一般函数的调用相似可以单独使用，也可以作为表达式的一部分。

常见使用场景

（1）作为参数传递（如 sorted, map, filter）

# 按字符串长度排序列表
words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)  # 输出 ['date', 'apple', 'banana', 'cherry']

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

# 对每个元素平方
squared = list(map(lambda x: x**2, numbers))
print(squared)       # 输出 [1, 4, 9, 16, 25]

 filter（）函数在前面提过，过滤出满足条件的函数。

（2）快速定义简单逻辑

# 判断是否为偶数
is_even = lambda x: x % 2 == 0
print(is_even(4))  # True

# 拼接字符串
greet = lambda name: f"Hello, {name}!"
print(greet("Alice"))  # Hello, Alice!

（3）结合条件表达式

# 返回两数中的较大值
max_value = lambda a, b: a if a > b else b
print(max_value(5, 8))  # 8

四、补充：

解包返回值：

         Python 中一种便捷的语法，用于将函数返回的多个值（通常是元组、列表等可迭代对象）直接拆分并赋值给多个变量。它的核心目的是让代码更简洁、可读性更强。

【例】假设有一个函数返回两个值：

​def get_coordinates():
    x = 3
    y = 4
    return x, y  # 实际返回的是元组 (3, 4)

​

不解包的情况：

直接获取返回值时，会得到一个元组：

coords = get_coordinates()
print(coords)        # 输出 (3, 4)
print(coords[0])     # 输出 3（通过索引访问）
print(coords[1])     # 输出 4

解包的情况：

将元组中的值直接拆分为两个变量：

x, y = get_coordinates()  # 解包赋值
print(x)  # 输出 3
print(y)  # 输出 4

解包具有灵活性：

（1）适用于任意可迭代对象

        不仅是元组，列表、字符串等可迭代对象也可以解包：

def get_data():
    return ["Alice", 25, "Engineer"]

name, age, job = get_data()  # 解包列表
print(name)  # Alice

（2）忽略不需要的值

        用下划线 _ 占位忽略不需要的返回值：

x, _ = get_coordinates()  # 只要 x，忽略 y
print(x)  # 3

（3）解包嵌套结构

        甚至可以解包嵌套的返回值（如元组中的元组）：

def nested_data():
    return (1, (2, 3))

a, (b, c) = nested_data()
print(a, b, c)  # 1 2 3

（4）使用 * 处理剩余值

用 * 变量名 接收剩余的所有值（返回列表）：

def multiple_values():
    return 1, 2, 3, 4, 5

first, *middle, last = multiple_values()
print(first)   # 1
print(middle)  # [2, 3, 4]（中间的数值被封装为列表）
print(last)    # 5

注意事项：

（1）变量数量必须匹配：

        左侧变量数必须与返回值数量一致，否则会报错：

x, y, z = get_coordinates()  # 错误！元组只有 2 个值，但尝试解包给 3 个变量

（2）返回值必须是可迭代对象：

        如果函数返回单个值（非元组/列表等），尝试解包会报错：

def single_value():
    return 5

a, b = single_value()  # 错误！单个整数无法解包