21. 变量作用域与名称解析

# 全局变量——在模块层级定义
total_users = 0
 
def show_user_count():
    # 这个函数可以读取全局变量
    print(f"Total users: {total_users}")
 
show_user_count()  # Output: Total users: 0
print(total_users)  # Output: 0

def calculate_discount(price):
    # discount_rate 是此函数的局部变量
    discount_rate = 0.15
    discount_amount = price * discount_rate
    return discount_amount
 
result = calculate_discount(100)
print(result)  # Output: 15.0
 
# 这会导致错误——这里不存在 discount_rate
# print(discount_rate)  # NameError: name 'discount_rate' is not defined

def calculate_tax(amount):
    rate = 0.08  # 局部变量
    return amount * rate
 
def calculate_shipping(weight):
    rate = 5.00  # 名称相同但不同的局部变量
    return weight * rate
 
tax = calculate_tax(100)
shipping = calculate_shipping(3)
 
print(f"Tax: ${tax}")         # Output: Tax: $8.0
print(f"Shipping: ${shipping}")  # Output: Shipping: $15.0

# 全局配置
max_login_attempts = 3
 
def check_login(password):
    # 读取全局变量
    if password == "secret123":
        return "Login successful"
    else:
        return f"Invalid password. You have {max_login_attempts} attempts."
 
result = check_login("wrong")
print(result)  # Output: Invalid password. You have 3 attempts.

counter = 0  # 全局变量
 
def increment_counter():
    # WARNING: 这会创建一个名为 counter 的新局部变量——仅用于演示
    # PROBLEM: 在对局部 counter 赋值之前就尝试读取它
    counter = counter + 1  # UnboundLocalError: local variable 'counter' referenced before assignment
    print(counter)
 
# increment_counter() # This call results in UnboundLocalError

message = "Hello"  # 全局变量
 
def show_message():
    print(message)  # 这能工作——只是读取全局变量
    
def change_message():
    # WARNING: 这演示了一个常见错误——仅用于演示
    # PROBLEM: Python 看到下面的赋值，所以 message 在整个函数中都被当作局部变量
    print(message)  # UnboundLocalError!
    message = "Goodbye"  # 这会让 message 在整个函数中都变为局部变量
 
show_message()  # Output: Hello
# change_message()  # This call results in UnboundLocalError

def greet(name):  # 'name' 是一个局部变量
    greeting = f"Hello, {name}!"  # 'greeting' 也是局部变量
    return greeting
 
message = greet("Alice")
print(message)  # Output: Hello, Alice!
 
# 这里既不存在 'name' 也不存在 'greeting'
# print(name)  # NameError

# 全局配置
tax_rate = 0.08
free_shipping_threshold = 50
 
def calculate_total(subtotal):
    # 本次计算使用的局部变量
    tax = subtotal * tax_rate  # 读取全局 tax_rate
    
    # 确定运费
    if subtotal >= free_shipping_threshold:  # 读取全局阈值
        shipping = 0
    else:
        shipping = 5.99
    
    total = subtotal + tax + shipping
    return total
 
# 针对不同购物车金额计算
cart1 = calculate_total(30)
cart2 = calculate_total(60)
 
print(f"Cart 1 total: ${cart1:.2f}")  # Output: Cart 1 total: $38.39
print(f"Cart 2 total: ${cart2:.2f}")  # Output: Cart 2 total: $64.80

def calculate_price():
    price = 100  # 局部变量
    tax = 0.08   # 局部变量
    total = price * (1 + tax)
    return total
 
result = calculate_price()
print(result)  # Output: 108.0

# 全局变量
default_tax_rate = 0.08
default_currency = "USD"
 
def calculate_price(amount):
    # 'amount' 是局部变量，会立即找到
    # 'default_tax_rate' 不是局部变量，会在全局作用域中找到
    total = amount * (1 + default_tax_rate)
    return total
 
result = calculate_price(100)
print(result)  # Output: 108.0

def process_data(numbers):
    # 'numbers' 是局部变量
    # 'len' 既不是局部也不是全局——它是内置的
    count = len(numbers)
    
    # 'max' 也是内置的
    maximum = max(numbers)
    
    return count, maximum
 
data = [10, 25, 15, 30, 20]
result = process_data(data)
print(result)  # Output: (5, 30)

def outer_function():
    outer_var = "I'm from outer"  # 对 inner_function 来说属于封闭作用域
    
    def inner_function():
        inner_var = "I'm from inner"  # inner_function 的局部变量
        # inner_function 可以看到 inner_var（局部）和 outer_var（封闭）
        print(inner_var)   # Output: I'm from inner
        print(outer_var)   # Output: I'm from outer
    
    inner_function()
 
outer_function()

# 内置：len（由 Python 提供）
# 全局：multiplier
multiplier = 10
 
def outer(x):
    # inner 的封闭作用域
    y = 5
    
    def inner(z):
        # 局部作用域
        # z 是局部变量 (L)
        # y 来自封闭作用域 (E)
        # multiplier 来自全局作用域 (G)
        # len 来自内置作用域 (B)
        result = len([z, y, multiplier])  # 使用全部四种作用域！
        return z + y + multiplier
 
    return inner(3)
 
answer = outer(100)
print(answer)  # Output: 18

value = "global"
 
def outer():
    value = "enclosing"
    
    def inner():
        value = "local"
        print(value)  # Which value?
    
    inner()
    print(value)  # Which value?
 
outer()
print(value)  # Which value?

local
enclosing
global

counter = 0  # 全局变量
 
def increment():
    # WARNING: 这会创建一个名为 counter 的新局部变量——仅用于演示
    # PROBLEM: 在对局部 counter 赋值之前就尝试读取它
    counter = counter + 1  # UnboundLocalError!
    
# increment()  # This call results in UnboundLocalError

counter = 0  # 全局变量
 
def increment():
    global counter  # 告诉 Python 使用全局 counter
    counter = counter + 1  # 现在会修改全局变量
 
print(f"Before: {counter}")  # Output: Before: 0
increment()
print(f"After: {counter}")   # Output: After: 1
increment()
print(f"After again: {counter}")  # Output: After again: 2

total_sales = 0
total_customers = 0
 
def record_sale(amount):
    global total_sales, total_customers
    total_sales += amount
    total_customers += 1
 
print(f"Sales: ${total_sales}, Customers: {total_customers}")
# Output: Sales: $0, Customers: 0
 
record_sale(25.50)
record_sale(30.00)
 
print(f"Sales: ${total_sales}, Customers: {total_customers}")
# Output: Sales: $55.5, Customers: 2

# 游戏状态
player_score = 0
player_lives = 3
game_over = False
 
def award_points(points):
    global player_score
    player_score += points
    print(f"Score: {player_score}")
 
def lose_life():
    global player_lives, game_over
    player_lives -= 1
    print(f"Lives remaining: {player_lives}")
    
    if player_lives <= 0:
        game_over = True
        print("Game Over!")
 
def check_game_status():
    # 只是读取全局变量——不需要 global 关键字
    if game_over:
        return "Game Over"
    else:
        return f"Playing - Score: {player_score}, Lives: {player_lives}"
 
# 进行游戏
award_points(100)    # Output: Score: 100
award_points(50)     # Output: Score: 150
lose_life()          # Output: Lives remaining: 2
print(check_game_status())  # Output: Playing - Score: 150, Lives: 2

total = 0
 
def add_to_total(value):
    global total
    total += value
 
# 这个函数做了什么？不读代码你看不出来
add_to_total(10)

def add_to_total(current_total, value):
    return current_total + value
 
total = 0
total = add_to_total(total, 10)  # 清晰：total 正在被更新

# 难以测试——依赖全局状态
score = 0
 
def add_score(points):
    global score
    score += points
 
# 每个测试都需要重置 score
# Test 1
score = 0
add_score(10)
assert score == 10
 
# Test 2 - must reset score again
score = 0
add_score(20)
assert score == 20

# 这个函数只有在存在名为 'inventory' 的全局变量时才工作
inventory = []
 
def add_item(item):
    global inventory
    inventory.append(item)

# 使用 global（不太理想）
balance = 1000
 
def withdraw(amount):
    global balance
    if amount <= balance:
        balance -= amount
        return True
    return False
 
withdraw(100)
print(balance)  # Output: 900

# 使用返回值（更好）
def withdraw(balance, amount):
    if amount <= balance:
        return balance - amount, True
    return balance, False
 
balance = 1000
balance, success = withdraw(balance, 100)
print(balance)  # Output: 900

# 全应用范围设置
debug_mode = False
log_level = "INFO"
 
def enable_debug():
    global debug_mode, log_level
    debug_mode = True
    log_level = "DEBUG"

# 用于调试：追踪函数调用次数
_function_call_count = 0
 
def tracked_function():
    global _function_call_count
    _function_call_count += 1
    # ... rest of function

def outer():
    count = 0  # outer 作用域中的变量
    
    def inner():
        # WARNING: 这会创建一个名为 count 的新局部变量——仅用于演示
        # PROBLEM: 在对局部 count 赋值之前就尝试读取它
        count = count + 1  # UnboundLocalError!
        print(count)
    
    inner()
 
# outer()  # This call results in UnboundLocalError

def outer():
    count = 0  # outer 作用域中的变量
    
    def inner():
        nonlocal count  # 使用 outer 作用域中的 count
        count = count + 1
        print(f"Count in inner: {count}")
    
    print(f"Count before: {count}")  # Output: Count before: 0
    inner()                          # Output: Count in inner: 1
    print(f"Count after: {count}")   # Output: Count after: 1
 
outer()

def create_counter():
    count = 0  # 对 increment 来说，这是封闭作用域中的变量
    
    def increment():
        nonlocal count  # 修改封闭作用域中的 count
        count += 1
        return count
    
    return increment  # 返回内部函数
 
# 创建一个计数器
counter1 = create_counter()
 
print(counter1())  # Output: 1
print(counter1())  # Output: 2
print(counter1())  # Output: 3
 
# 再创建一个相互独立的计数器
counter2 = create_counter()
 
print(counter2())  # Output: 1
print(counter2())  # Output: 2

x = "global"
 
def outer():
    x = "enclosing"
    
    def use_global():
        global x  # 引用的是全局 x
        print(f"use_global sees: {x}")  # Output: use_global sees: global
    
    def use_nonlocal():
        nonlocal x  # 引用的是 outer 的 x
        print(f"use_nonlocal sees: {x}")  # Output: use_nonlocal sees: enclosing
    
    use_global()
    use_nonlocal()
 
outer()

x = "global"
 
def func():
    nonlocal x  # SyntaxError: no binding for nonlocal 'x' found
    x = "modified"

def outer():
    def inner():
        nonlocal count  # SyntaxError: no binding for nonlocal 'count' found

x = 42
print(x)  # Output: 42
 
del x
 
# print(x)  # NameError: name 'x' is not defined

# 创建一个列表以及两个引用它的名称
original = [1, 2, 3]
reference = original  # 两个名称都引用同一个列表
 
print(original)   # Output: [1, 2, 3]
print(reference)  # Output: [1, 2, 3]
 
# 删除其中一个名称
del original
 
# 列表仍然存在，因为 'reference' 仍然引用它
print(reference)  # Output: [1, 2, 3]
 
# print(original)  # NameError: name 'original' is not defined

data = [1, 2, 3]  # 创建列表，'data' 引用它
 
del data  # 删除名称 'data'
 
# 现在列表没有任何引用了，所以 Python 最终会删除它
# （这是自动发生的——你不需要做任何事）

# 按索引删除列表元素
numbers = [10, 20, 30, 40, 50]
del numbers[2]  # 删除索引 2 处的元素
print(numbers)  # Output: [10, 20, 40, 50]
 
# 删除列表切片
numbers = [10, 20, 30, 40, 50]
del numbers[1:3]  # 删除索引 1 到 3（不含 3）的元素
print(numbers)  # Output: [10, 40, 50]
 
# 删除字典条目
person = {'name': 'Alice', 'age': 30, 'city': 'Boston'}
del person['age']
print(person)  # Output: {'name': 'Alice', 'city': 'Boston'}