在 Python 中，嵌套（Nesting） 是指在一个代码块内部包含另一个代码块，例如在函数、条件语句、循环或数据结构中嵌入其他结构。嵌套是编程中常见的组织代码的方式，但过度嵌套可能导致代码难以阅读（称为“嵌套地狱”）。

1. 常见的嵌套结构

(1) 嵌套函数（函数内部定义函数）

def outer_func():
    def inner_func():  # 嵌套函数
        print("Inside inner function")
    inner_func()  # 调用内部函数

outer_func()  # 输出: "Inside inner function"

• 特点：
• 内部函数 (inner_func) 只能在外部函数 (outer_func) 内部访问。
• 常用于闭包（Closure）或封装逻辑。

(2) 嵌套条件语句（if-elif-else 嵌套）

x = 10
if x > 5:
    if x < 15:  # 嵌套 if
        print("x is between 5 and 15")
    else:
        print("x is >= 15")
else:
    print("x is <= 5")

特点：

• 可以多层嵌套，但超过 3 层会使代码难以维护。
• 可以用 and/or 优化：

if 5 < x < 15:  # 更简洁
    print("x is between 5 and 15")
    

(3) 嵌套循环（循环内部再循环）

for i in range(3):
    for j in range(2):  # 嵌套循环
        print(f"i={i}, j={j}")

输出：

i=0, j=0
i=0, j=1
i=1, j=0
i=1, j=1
i=2, j=0
i=2, j=1

• 特点：
• 常用于处理二维数据（如矩阵、表格）。
• 嵌套层数越多，时间复杂度越高（如 3 层循环 → O(n^3)）。

(4) 嵌套数据结构（列表/字典/集合嵌套）

# 嵌套列表（二维列表）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 嵌套字典
person = {
    "name": "Alice",
    "address": {
        "city": "New York",
        "zip": "10001"
    }
}

特点：

• 适用于存储复杂数据（如 JSON）。
• 访问方式：

print(matrix[1][2])  # 输出: 6
print(person["address"]["city"])  # 输出: "New York"

(5) 嵌套类（类内部定义类）

class OuterClass:
    class InnerClass:  # 嵌套类
        def __init__(self):
            print("Inner class instance")

    def create_inner(self):
        return self.InnerClass()

outer = OuterClass()
inner = outer.create_inner()  # 输出: "Inner class instance"

特点：

• 内部类通常用于特定场景（如实现 Builder 模式）。
• 较少使用，除非有明确的封装需求。

2. 嵌套的优缺点

3. 如何避免过度嵌套？

(1) 使用函数拆分

# 嵌套较深
if condition1:
    if condition2:
        if condition3:
            do_something()

# 优化：拆分成函数
def check_conditions():
    return condition1 and condition2 and condition3

if check_conditions():
    do_something()

(2) 使用continue/break/return提前退出

# 嵌套循环优化
for i in range(10):
    if i % 2 != 0:
        continue  # 跳过奇数
    print(i)

(3) 使用列表推导式或生成器

# 嵌套循环 → 列表推导式
result = [(x, y) for x in range(3) for y in range(2)]
print(result)  # [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

(4) 使用match-case（Python 3.10+）替代多层if-else

match value:
    case 1:
        print("One")
    case 2:
        print("Two")
    case _:
        print("Other")

总结

• 嵌套 是 Python 中组织代码的常见方式，适用于函数、条件、循环、数据结构等。
• 避免过度嵌套，否则代码可读性和性能会下降。
• 优化方法：拆分成函数、提前退出、使用推导式或 match-case。

你可以尝试写一些嵌套代码，然后优化它，看看哪种方式更清晰！