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  # Global variable
 
def increment_counter():
    # WARNING: This creates a NEW local variable named counter - for demonstration only
    # PROBLEM: Trying to read counter before assigning to it locally
    counter = counter + 1  # UnboundLocalError: local variable 'counter' referenced before assignment
    print(counter)
 
# increment_counter() # This call results in UnboundLocalError

message = "Hello"  # Global variable
 
def show_message():
    print(message)  # This works - just reading the global
    
def change_message():
    # WARNING: This demonstrates a common error - for demonstration only
    # PROBLEM: Python sees assignment below, so message is treated as local throughout
    print(message)  # UnboundLocalError!
    message = "Goodbye"  # This makes message local for the ENTIRE function
 
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()

# Built-in: len (Python provides this)
# Global: 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])  # 4 つのスコープすべてを使う！
        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  # Global variable
 
def increment():
    # WARNING: This creates a NEW local variable named counter - for demonstration only
    # PROBLEM: Trying to read counter before assigning to it locally
    counter = counter + 1  # UnboundLocalError!
    
# increment()  # This call results in UnboundLocalError

counter = 0  # Global variable
 
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 - もう一度 score をリセットしなければならない
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: This creates a NEW local variable named count - for demonstration only
        # PROBLEM: Trying to read count before assigning to it locally
        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
 
# もう 1 つ独立したカウンタを作成する
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

# リストを作り、それを参照する 2 つの名前を作る
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（除く）までの要素を削除
print(numbers)  # Output: [10, 40, 50]
 
# 辞書エントリを削除する
person = {'name': 'Alice', 'age': 30, 'city': 'Boston'}
del person['age']
print(person)  # Output: {'name': 'Alice', 'city': 'Boston'}