1 __main__

1.1 name 变量

__name__ 是 Python 的一个内置变量，用于表示当前模块的名称。其值会根据模块的使用方式而变化：

1.1.1 当模块作为主程序直接运行时

此时 __name__ 的值被自动设置为 "__main__"。

示例：创建一个 module.py 文件，内容如下：

print(f"模块的 __name__ 值: {__name__}")

直接运行该文件（python module.py），输出结果为：

模块的 __name__ 值: __main__

1.1.2 当模块被其他模块导入时

此时 __name__ 的值被设置为该模块的文件名（不包含 .py 扩展名）。

示例：创建另一个文件 import_module.py，内容如下：

import module  # 导入上面创建的 module.py

运行 import_module.py，输出结果为：

模块的 __name__ 值: module

1.2 __main__ 的含义

__main__ 是一个特殊的字符串常量，用于表示当前模块是作为主程序运行的。

它通常不单独使用，而是与 __name__ 结合，用于判断模块的运行状态：

• 当 __name__ == "__main__" 时，表明模块是直接运行的
• 当 __name__ != "__main__" 时，表明模块是被导入的

1.3 if __name__ == __main__

这是 Python 中一种非常常见的代码模式，用于控制代码在不同场景下的执行行为。

• 当模块作为独立脚本运行时，执行 if 块内的代码
• 当模块被其他模块导入时，不执行 if 块内的代码

步骤 1：创建 example.py 文件：

def greet():print("来自 example 模块的问候！")# 根据模块运行方式执行不同代码
if __name__ == "__main__":print("该脚本正在直接运行。")greet()  # 直接运行时调用函数
else:print("该脚本作为模块被导入。")

步骤 2：直接运行 example.py：

python example.py

输出结果：

该脚本正在直接运行。
来自 example 模块的问候！

步骤 3：创建 another_script.py 并导入 example：

import example  # 导入模块example.greet()  # 调用模块中的函数

运行 another_script.py：

python another_script.py

输出结果：

该脚本作为模块被导入。
来自 example 模块的问候！

1.5 小结

1. __name__ 是内置变量，表示当前模块的名称
   • 直接运行模块时，__name__ = "__main__"
   • 模块被导入时，__name__ = 模块文件名（不含 .py）
2. if __name__ == "__main__": 是 Python 的常用模式
   • 用于区分模块的两种使用方式：直接运行 vs 被导入
   • 使模块既可以作为独立程序运行，又可以作为库被其他模块导入

2 lambda表达式

2.1 基本概念

lambda 函数是 Python 中一种特殊的函数形式，也被称为匿名函数，即没有正式名称的函数。它旨在快速创建简单的、单行的函数，尤其适合需要临时使用的短小功能。

与常规函数（使用 def 定义）相比，lambda 函数的特点：

• 匿名性：没有函数名称，只能通过赋值或作为参数传递使用
• 简洁性：通常只包含一行代码和一个表达式
• 临时性：适用于短期使用的简单功能

2.2 lambda 函数语法

lambda arguments: expression

• lambda：Python 关键字，用于定义 lambda 函数
• arguments：参数列表，可以包含 0 个或多个参数（用逗号分隔）
• expression：一个表达式，用于计算并返回结果（lambda 函数的返回值）

注意：lambda 函数只能包含一个表达式，不能包含复杂的代码块（如循环、条件语句的多行形式等）

2.3 使用示例

无参数的 lambda 函数

# 定义无参数的 lambda 函数
f = lambda: "Hello, world!"# 调用函数
print(f())  # 输出: Hello, world!

单个参数的 lambda 函数

# 定义接收一个参数的 lambda 函数（计算参数加 10）
x = lambda a: a + 10# 调用函数
print(x(5))  # 输出: 15
print(x(10))  # 输出: 20

多个参数的 lambda 函数

# 两个参数：计算 a 乘以 b
multiply = lambda a, b: a * b
print(multiply(5, 6))  # 输出: 30# 三个参数：计算 a + b + c
add_three = lambda a, b, c: a + b + c
print(add_three(5, 6, 2))  # 输出: 13

带默认参数的 lambda 函数

# 带默认值的参数
greet = lambda name, greeting="Hello": f"{greeting}, {name}!"
print(greet("Alice"))  # 输出: Hello, Alice!
print(greet("Bob", "Hi"))  # 输出: Hi, Bob!

2.4 与高阶函数结合使用

lambda 函数最常见的用途是作为参数传递给高阶函数（接收函数作为参数的函数），如 map()、filter()、reduce() 等。

2.4.1 与 map () 结合

map(func, iterable) 会将函数应用于可迭代对象的每个元素，返回一个迭代器。

# 计算列表中每个元素的平方
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared)  # 输出: [1, 4, 9, 16, 25]# 处理多个可迭代对象
a = [1, 2, 3]
b = [4, 5, 6]
sum_list = list(map(lambda x, y: x + y, a, b))
print(sum_list)  # 输出: [5, 7, 9]

2.4.2 与 filter () 结合

filter(func, iterable) 用于筛选可迭代对象中满足函数条件的元素，返回一个迭代器。

# 筛选列表中的偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # 输出: [2, 4, 6, 8]# 筛选长度大于 3 的字符串
words = ["apple", "cat", "banana", "dog", "grape"]
long_words = list(filter(lambda s: len(s) > 3, words))
print(long_words)  # 输出: ['apple', 'banana', 'grape']

2.4.3 与 reduce () 结合

reduce(func, iterable) 用于对可迭代对象中的元素进行累积计算（需从 functools 导入）。

from functools import reduce# 计算列表元素的累积乘积
numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 输出: 120（1*2*3*4*5的结果）# 计算列表元素的累积和
sum_total = reduce(lambda x, y: x + y, numbers)
print(sum_total)  # 输出: 15（1+2+3+4+5的结果）

2.5 lambda 函数 vs 常规函数（def）

特性	lambda 函数	常规函数（def）
名称	匿名，无名称	有函数名
定义	使用 lambda 关键字	使用 def 关键字
表达式	只能有一个表达式	可以包含多个语句和代码块
返回值	自动返回表达式结果	需要显式使用 return 语句
文档字符串	不支持	支持（可通过 doc 访问）
适用场景	简单的单行功能，临时使用	复杂功能，需要复用的函数

示例对比：

# 使用 lambda 定义
add_lambda = lambda a, b: a + b# 使用 def 定义
def add_def(a, b):return a + b# 功能相同
print(add_lambda(2, 3))  # 输出: 5
print(add_def(2, 3))     # 输出: 5