def outer():
    x = 10          # x 定义在 outer 函数内部
    def inner():
        print(x)    # 这里能访问 x 吗？
    inner()

outer()
print(x)            # ❌ 这里能访问 x 吗？

# 如果没有作用域隔离...
def calc_a():
    total = 100   # 会覆盖 calc_b 的 total 吗？

def calc_b():
    total = 200   # 会覆盖 calc_a 的 total 吗？

# Python 内部大致是这样管理命名空间的
scope = {
    'x': 42,
    'name': 'Alice',
    'items': [1, 2, 3]
}

# 内置命名空间
print           # ← 来自 Built-in，不需要定义

# 全局命名空间
x = "全局 x"    # ← 全局作用域

def outer():
    y = "封闭 y"  # ← outer 的局部，对 inner 来说是 Enclosing

    def inner():
        z = "局部 z"  # ← inner 的局部
        print(z)      # L：找到局部 z
        print(y)      # E：local 没有 y，去 enclosing 找
        print(x)      # G：前两层都没有，去全局找
        print(len)    # B：全局也没有 len，去内置找

    inner()

outer()

x = 10

def shadow():
    x = 20      # 这个 x 是局部变量，遮蔽了全局 x
    print(x)    # → 20

shadow()
print(x)        # → 10（全局 x 不受影响）

nums = [1, 2, 3]

def mutate():
    nums.append(4)          # ✅ 可以！这是"读取后修改"，不是"赋值"
    print(nums)             # → [1, 2, 3, 4]

def reassign():
    nums = [4, 5, 6]       # ⚡ 这是"赋值"——创建了新局部变量 nums
    print(nums)             # → [4, 5, 6]

mutate()
reassign()
print(nums)                 # → [1, 2, 3, 4]（mutate 真的修改了列表）

count = 0           # 全局变量

def increment():
    global count    # 声明：这个 count 是全局的
    count += 1
    print(f"count = {count}")

increment()         # → count = 1
increment()         # → count = 2
print(count)        # → 2（确实被修改了）

count = 0

def increment():
    # 这里没有 global 声明
    count += 1      # 🚫 UnboundLocalError!

def outer():
    x = 10              # outer 的局部变量

    def inner():
        nonlocal x      # 声明：这个 x 来自外层函数
        x = 20          # 修改的是 outer 的 x，不是创建新变量
        print(f"inner: x = {x}")

    inner()
    print(f"outer: x = {x}")  # → 20（被 inner 修改了）

outer()

def outer():
    x = 10

    def inner_bad():
        x = 20          # 这创建了一个新的局部 x，不会影响 outer 的 x
        print(f"inner_bad: x = {x}")

    def inner_good():
        nonlocal x
        x = 20          # 这修改了 outer 的 x
        print(f"inner_good: x = {x}")

    inner_bad()
    print(f"after inner_bad: x = {x}")   # → 10（没变）

    inner_good()
    print(f"after inner_good: x = {x}")  # → 20（变了）

outer()

x = "全局"

def a():
    x = "a 层的 x"       # 局部

    def b():
        x = "b 层的 x"   # a 到 b 之间还有一个局部

        def c():
            global x     # 跳过 a 层和 b 层，直接到全局
            x = "被 c 修改的全局 x"

        def d():
            nonlocal x   # 去最近的外层找 x → b 层的 x
            x = "被 d 修改的 b 层 x"

        c()
        d()
        print("b:", x)   # → "被 d 修改的 b 层 x"

    b()
    print("a:", x)       # → "a 层的 x"（没被 nonlocal 影响）

a()
print("全局:", x)        # → "被 c 修改的全局 x"

def make_greeter(greeting):
    def greet(name):
        return f"{greeting}, {name}!"
    return greet

say_hi = make_greeter("你好")
say_hello = make_greeter("Hello")

print(say_hi("Alice"))      # → 你好, Alice!
print(say_hello("Bob"))     # → Hello, Bob!

def make_counter():
    count = 0

    def counter():
        nonlocal count
        count += 1
        return count

    return counter

ct = make_counter()
print(ct())          # → 1
print(ct())          # → 2
print(ct())          # → 3

# 查看闭包的内部结构
print(ct.__closure__)           # 闭包元组
print(ct.__closure__[0])        # cell 对象
print(ct.__closure__[0].cell_contents)  # → 3（当前值）
print(ct.__code__.co_free_vars) # → ('count',) 自由变量名

# 闭包实现数据封装
def create_secure_storage(initial_value=0):
    """创建一个带"私有"状态的计数器"""
    _value = initial_value

    def get():
        """获取当前值"""
        return _value

    def set(new_value):
        """设置新值（有验证）"""
        nonlocal _value
        if not isinstance(new_value, (int, float)):
            raise TypeError("只支持数字类型")
        _value = new_value

    # 返回操作接口，但不直接暴露 _value
    return {"get": get, "set": set}

storage = create_secure_storage(100)
print(storage["get"]())           # → 100
storage["set"](200)
print(storage["get"]())           # → 200
# storage["set"]("abc")            # ← TypeError
# print(storage["_value"])          # ← NameError（无法直接访问！）

def create_multipliers():
    multipliers = []
    for i in range(5):
        def multiplier(x):
            return x * i       # i 是自由变量
        multipliers.append(multiplier)
    return multipliers

multipliers = create_multipliers()
for m in multipliers:
    print(m(2), end=" ")  # → 8 8 8 8 8  (不是 0 2 4 6 8! 😱)

# 方案 1：默认参数（立即绑定当前 i 的值）
def create_multipliers_fixed1():
    multipliers = []
    for i in range(5):
        def multiplier(x, i=i):   # 默认参数在定义时求值
            return x * i
        multipliers.append(multiplier)
    return multipliers

# 方案 2：额外闭包层（创建新作用域）
def create_multipliers_fixed2():
    multipliers = []
    for i in range(5):
        def make_multiplier(i):
            def multiplier(x):
                return x * i
            return multiplier
        multipliers.append(make_multiplier(i))
    return multipliers

print([m(2) for m in create_multipliers_fixed1()])  # → [0, 2, 4, 6, 8] ✅
print([m(2) for m in create_multipliers_fixed2()])  # → [0, 2, 4, 6, 8] ✅

# 闭包方式
def counter_closure():
    count = 0
    def inc():
        nonlocal count
        count += 1
        return count
    return inc

# 类方式
class CounterClass:
    def __init__(self):
        self.count = 0
    def inc(self):
        self.count += 1
        return self.count

c1 = counter_closure()
c2 = CounterClass()
print(c1())        # → 1
print(c2.inc())    # → 1

# 1. 变量创建：赋值时创建
x = 42          # 对象 42 被创建，x 引用它

# 2. 变量存活：只要有引用指向它
y = x           # 42 的引用计数 +1

# 3. 变量销毁：离开作用域时
def demo():
    temp = "临时"  # 函数离开时，temp 被销毁
    print(temp)

demo()
# print(temp)   # NameError ❌

import sys

# 全局变量
module_var = "我活在模块中"  # 创建于导入时，销毁于程序退出

def outer():
    # Enclosing 变量
    enclosing_var = "我活在 outer 函数中"  # 创建于 outer() 调用时

    def inner():
        # 局部变量
        local_var = "我活在 inner 函数中"  # 创建于 inner() 调用时
        print(local_var)
        print(enclosing_var)   # 引用外层变量

    inner()
    # inner() 返回，local_var 被销毁
    # outer() 返回，enclosing_var 被销毁

outer()

def make_closure():
    # 这个变量在 make_closure 返回后本该销毁
    data = [1, 2, 3]

    def keep():
        print(f"我还记得 data: {data}")

    return keep

keeper = make_closure()
# 此时 make_closure 已经执行完毕
# 但 data 没有被销毁——因为 keeper 的闭包还引用着它
keeper()  # → 我还记得 data: [1, 2, 3]

# 查看引用情况
import gc
print(gc.get_referrers(data))  # 注意：在函数外无法直接访问 data

import sys

x = [1, 2, 3]
print(sys.getrefcount(x))  # → 2（x 的引用 + getrefcount 参数）

y = x
print(sys.getrefcount(x))  # → 3

del y                       # 引用计数 -1
print(sys.getrefcount(x))  # → 2

# ⚠️ 循环引用
a = []
b = []
a.append(b)
b.append(a)
# a 和 b 互相引用，引用计数永远不会归零
# Python 的垃圾回收器会检测并回收这种情况

def create_counter(start=0, step=1, min_val=None, max_val=None):
    """
    创建计数器闭包

    参数:
        start: 起始值（默认 0）
        step: 步长（默认 1）
        min_val: 最小值限制（可选）
        max_val: 最大值限制（可选）

    返回:
        包含 next/reset/peek 方法的字典
    """
    current = start

    def next():
        """增加计数并返回新值"""
        nonlocal current
        new_val = current + step

        # 检查上限
        if max_val is not None and new_val > max_val:
            raise StopIteration(f"已达到上限 {max_val}")

        # 检查下限
        if min_val is not None and new_val < min_val:
            raise StopIteration(f"已达到下限 {min_val}")

        current = new_val
        return current

    def reset():
        """重置到起始值"""
        nonlocal current
        current = start

    def peek():
        """查看当前值（不修改）"""
        return current

    # 返回操作接口
    return {
        "next": next,
        "reset": reset,
        "peek": peek,
        "current": current  # 这不是闭包，只是当前值快照！
    }


# ============ 使用示例 ============

# 基础计数器：从 0 开始，步长 1
counter = create_counter()
print(counter["peek"]())      # → 0
print(counter["next"]())      # → 1
print(counter["next"]())      # → 2
counter["reset"]()
print(counter["peek"]())      # → 0

# 自定义计数器：从 100 开始，步长 -5，下限 80
counter2 = create_counter(start=100, step=-5, min_val=80)
print(counter2["next"]())     # → 95
print(counter2["next"]())     # → 90
print(counter2["next"]())     # → 85
print(counter2["next"]())     # → 80
# print(counter2["next"]())     # ← StopIteration!

# 多个计数器互不干扰
c3 = create_counter()
c4 = create_counter()
print(c3["next"]())           # → 1
print(c3["next"]())           # → 2
print(c4["next"]())           # → 1（c4 是独立的）

   def make_adder(n):
       def add(x):
           return x + n
       return add