21. 변수 스코프와 이름 해석

# 전역 변수 - 모듈 수준에서 정의됨
total_users = 0
 
def show_user_count():
    # 이 함수는 전역 변수를 READ할 수 있음
    print(f"Total users: {total_users}")
 
show_user_count()  # Output: Total users: 0
print(total_users)  # Output: 0

def calculate_discount(price):
    # discount_rate는 이 함수에 LOCAL임
    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():
    # 경고: 이는 counter라는 NEW 지역 변수를 만듭니다 - 시연용
    # 문제: 지역에 대입하기 전에 counter를 읽으려고 함
    counter = counter + 1  # UnboundLocalError: local variable 'counter' referenced before assignment
    print(counter)
 
# increment_counter() # 이 줄은 UnboundLocalError를 발생시킴

message = "Hello"  # 전역 변수
 
def show_message():
    print(message)  # 이건 동작합니다 - 전역을 그냥 읽음
    
def change_message():
    # 경고: 이는 흔한 오류를 보여줍니다 - 시연용
    # 문제: 아래의 대입을 보고 Python은 message를 함수 전체에서 지역으로 취급함
    print(message)  # UnboundLocalError!
    message = "Goodbye"  # 이로 인해 message는 함수 전체에서 지역변수로 취급하게 됨
 
show_message()  # Output: Hello
# change_message() # 이 줄은 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:  # 전역 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'은 지역/전역이 아니라 내장(built-in)임
    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의 enclosing 스코프에 있음
    
    def inner_function():
        inner_var = "I'm from inner"  # inner_function의 지역
        # inner_function은 inner_var(지역)과 outer_var(enclosing) 둘 다 볼 수 있음
        print(inner_var)   # Output: I'm from inner
        print(outer_var)   # Output: I'm from outer
    
    inner_function()
 
outer_function()

# Built-in: len (Python이 제공함)
# 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])  # 네 가지 스코프를 모두 사용!
        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)  # 어떤 value일까요?
    
    inner()
    print(value)  # 어떤 value일까요?
 
outer()
print(value)  # 어떤 value일까요?

local
enclosing
global

counter = 0  # 전역 변수
 
def increment():
    # 경고: 이는 counter라는 NEW 지역 변수를 만듭니다 - 시연용
    # 문제: 지역에 대입하기 전에 counter를 읽으려고 함
    counter = counter + 1  # UnboundLocalError!
    
# increment()  # 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 - 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
    # ... 나머지 함수

def outer():
    count = 0  # outer의 스코프에 있는 변수
    
    def inner():
        # 경고: 이는 count라는 NEW 지역 변수를 만듭니다 - 시연용
        # 문제: 지역에 대입하기 전에 count를 읽으려고 함
        count = count + 1  # UnboundLocalError!
        print(count)
    
    inner()
 
# outer()  # 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에 대한 enclosing 스코프에 있음
    
    def increment():
        nonlocal count  # enclosing 스코프의 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(미포함)까지 요소 제거
print(numbers)  # Output: [10, 40, 50]
 
# 딕셔너리 항목 삭제
person = {'name': 'Alice', 'age': 30, 'city': 'Boston'}
del person['age']
print(person)  # Output: {'name': 'Alice', 'city': 'Boston'}