09. 함수

def greet():
    print("안녕하세요!")
    print("함수에 오신 걸 환영합니다")

greet()      # 함수 호출 → 안에 든 코드가 실행됨
greet()      # 또 호출 (재사용!)
# 출력:
# 안녕하세요!
# 함수에 오신 걸 환영합니다
# 안녕하세요!
# 함수에 오신 걸 환영합니다

def  greet  (        )  :
─┬─  ──┬──   ─┬─       ┬
 │     │      │        └ 콜론 (이후 들여쓴 블록이 함수 몸체)
 │     │      └ 괄호 (인자가 들어갈 자리, 지금은 비어 있음)
 │     └ 함수 이름 (snake_case)
 └ "함수를 정의한다"는 키워드 def

def greet(name):
    print(f"안녕하세요, {name}님!")

greet("민지")     # 안녕하세요, 민지님!
greet("현우")     # 안녕하세요, 현우님!

def introduce(name, age):
    print(f"{name}님은 {age}살입니다")

introduce("민지", 25)     # 민지님은 25살입니다

def add(a, b):
    return a + b        # 결과를 돌려줌

result = add(3, 5)      # 돌려받은 값을 변수에 담음
print(result)           # 8
print(add(10, 20) * 2)  # 60   ← 돌려받은 값으로 계산도 가능

# print만 하는 함수: 화면에 보여줄 뿐, 값을 가져다 쓸 수 없음
def add_print(a, b):
    print(a + b)

# return 하는 함수: 값을 돌려줘서 재사용 가능
def add_return(a, b):
    return a + b

x = add_print(3, 5)    # 화면엔 8이 찍히지만...
print(x)               # None  ← x에는 아무것도 안 담김!

y = add_return(3, 5)   # 화면엔 아무것도 안 나오지만...
print(y)               # 8     ← y에 결과가 담김!

def check_age(age):
    if age < 0:
        return "잘못된 나이"      # 여기서 함수 끝
    if age < 18:
        return "미성년자"
    return "성인"                 # 위 조건이 다 거짓일 때

print(check_age(-5))    # 잘못된 나이
print(check_age(15))    # 미성년자
print(check_age(30))    # 성인

def min_max(nums):
    return min(nums), max(nums)     # 두 값을 한 번에

low, high = min_max([3, 1, 4, 1, 5])   # 언패킹으로 받기
print(low, high)        # 1 5

def greet(name, greeting="안녕"):     # greeting의 기본값은 "안녕"
    return f"{greeting}, {name}님!"

print(greet("민지"))             # 안녕, 민지님!       (기본값 사용)
print(greet("현우", "반가워"))    # 반가워, 현우님!     (기본값 대체)

def profile(name, age, city):
    return f"{name} / {age}세 / {city}"

# 위치로 전달 (순서 중요)
print(profile("민지", 25, "서울"))

# 키워드로 전달 (순서 무관, 명확함)
print(profile(age=25, city="서울", name="민지"))
# 둘 다: 민지 / 25세 / 서울

def total(*nums):
    print(nums)             # 넘어온 값들이 튜플로
    return sum(nums)

print(total(1, 2, 3))       # (1, 2, 3) → 6
print(total(10, 20))        # (10, 20) → 30
print(total())              # () → 0

def make_profile(**info):
    for key, value in info.items():
        print(f"{key}: {value}")

make_profile(name="민지", age=25, city="서울")
# name: 민지
# age: 25
# city: 서울

def my_func():
    inside = "함수 안에서 태어남"
    print(inside)       # OK

my_func()               # 함수 안에서 태어남
print(inside)           # ❌ NameError! 함수 밖에선 inside를 모름

NameError: name 'inside' is not defined

greeting = "안녕"        # 전역 변수

def greet(name):
    print(f"{greeting}, {name}님!")   # 전역 greeting을 읽음 (OK)

greet("민지")            # 안녕, 민지님!

x = "전역"

def change():
    x = "지역"           # 전역 x를 바꾸는 게 아니라, 새 지역 x를 만듦
    print(x)             # 지역

change()                 # 지역
print(x)                 # 전역   ← 바깥 x는 그대로!

# 일반 함수
def square(n):
    return n ** 2

# 같은 일을 하는 람다
square = lambda n: n ** 2

print(square(5))     # 25

words = ["banana", "apple", "fig"]

# 길이 순으로 정렬 (기준을 람다로 전달)
print(sorted(words, key=lambda w: len(w)))
# ['fig', 'apple', 'banana']

# 숫자를 내림차순으로
nums = [3, 1, 4, 1, 5]
print(sorted(nums, key=lambda n: -n))
# [5, 4, 3, 1, 1]

# ❌ 나쁜 예: 같은 계산을 복사-붙여넣기
price1 = 10000
final1 = price1 - price1 * 0.1
print(f"할인가: {final1}원")

price2 = 20000
final2 = price2 - price2 * 0.1
print(f"할인가: {final2}원")

# ✅ 좋은 예: 함수로 한 번만 정의하고 재사용
def apply_discount(price, rate=0.1):
    return price - price * rate

print(f"할인가: {apply_discount(10000)}원")    # 할인가: 9000.0원
print(f"할인가: {apply_discount(20000)}원")    # 할인가: 18000.0원

def double(n):
    n * 2

result = double(5)
print(result)

count = 10
def update():
    count = 99
update()
print(count)

def bigger(a, b):
    return a if a > b else b      # 또는 return max(a, b)
print(bigger(7, 3))               # 7

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"
print(greet("Mina"))         # Hello, Mina!
print(greet("Mina", "Hi"))   # Hi, Mina!

def my_max(*nums):
    return max(nums)
print(my_max(3, 7, 2, 9, 4))   # 9