Ch4. Python 기초 — 함수와 모듈

함수(Function)란 무엇인가

**함수(Function)**는 특정 작업을 수행하는 코드 블록으로, 이름을 붙여서 필요할 때마다 호출할 수 있습니다.

함수를 사용하면:

코드 재사용성 증가 — 같은 코드를 반복 작성하지 않아도 됨
가독성 향상 — 코드가 기능 단위로 분리되어 읽기 쉬움
유지보수 용이 — 한 곳만 수정하면 전체에 적용

함수 정의와 호출

def 함수이름(매개변수1, 매개변수2, ...):
    """독스트링: 함수 설명 (선택사항)"""
    실행할_코드
    return 반환값  # 선택사항

# 함수 정의
def greet():
    print("안녕하세요!")
    print("파이썬에 오신 것을 환영합니다.")

# 함수 호출
greet()
greet()   # 몇 번이든 재사용 가능

출력:

안녕하세요!
파이썬에 오신 것을 환영합니다.
안녕하세요!
파이썬에 오신 것을 환영합니다.

매개변수(Parameter)와 인수(Argument)

매개변수(Parameter): 함수 정의 시 괄호 안의 변수명
인수(Argument): 함수 호출 시 전달하는 실제 값

# name이 매개변수
def greet(name):
    print(f"안녕하세요, {name}님!")

# "Alice"가 인수
greet("Alice")       # 안녕하세요, Alice님!
greet("홍길동")       # 안녕하세요, 홍길동님!

여러 매개변수

def add(a, b):
    result = a + b
    print(f"{a} + {b} = {result}")

add(3, 5)     # 3 + 5 = 8
add(10, 20)   # 10 + 20 = 30

return 문 — 반환값

return은 함수의 실행을 종료하고 값을 반환합니다.

def square(x):
    return x ** 2

result = square(5)
print(result)   # 25

# 여러 값 반환 (튜플로 반환)
def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([3, 1, 4, 1, 5, 9, 2, 6])
print(f"최솟값: {lo}, 최댓값: {hi}")   # 최솟값: 1, 최댓값: 9

return 없이 함수가 끝나면 자동으로 None을 반환합니다.

def no_return():
    print("반환값 없음")

result = no_return()
print(result)   # None

기본값 매개변수 (Default Parameter)

매개변수에 기본값을 설정하면, 인수를 생략했을 때 기본값이 사용됩니다.

def introduce(name, age=20, city="서울"):
    print(f"이름: {name}, 나이: {age}, 도시: {city}")

introduce("Alice")                    # 이름: Alice, 나이: 20, 도시: 서울
introduce("Bob", 25)                  # 이름: Bob, 나이: 25, 도시: 서울
introduce("Charlie", 30, "부산")      # 이름: Charlie, 나이: 30, 도시: 부산

주의: 기본값이 있는 매개변수는 반드시 기본값이 없는 매개변수 뒤에 위치해야 합니다.

# 잘못된 예 — 오류 발생!
def wrong(age=20, name):   # SyntaxError
    pass

# 올바른 예
def correct(name, age=20):
    pass

키워드 인수 (Keyword Argument)

함수를 호출할 때 매개변수 이름을 명시하여 인수를 전달할 수 있습니다.

def introduce(name, age, city):
    print(f"{name}, {age}세, {city} 거주")

# 위치 인수
introduce("Alice", 25, "서울")

# 키워드 인수 (순서 무관)
introduce(age=25, city="서울", name="Alice")

# 혼합 사용 (위치 인수가 먼저)
introduce("Alice", city="서울", age=25)

*args — 가변 위치 인수

몇 개의 인수가 전달될지 모를 때 *args를 사용합니다. 전달된 인수는 튜플로 묶입니다.

def total(*args):
    print(f"받은 인수: {args}")
    return sum(args)

print(total(1, 2, 3))             # 받은 인수: (1, 2, 3) → 6
print(total(10, 20, 30, 40, 50))  # 받은 인수: (10, 20, 30, 40, 50) → 150

def print_all(separator, *items):
    print(separator.join(str(item) for item in items))

print_all(", ", "사과", "바나나", "딸기")   # 사과, 바나나, 딸기
print_all(" | ", 1, 2, 3, 4)               # 1 | 2 | 3 | 4

**kwargs — 가변 키워드 인수

키워드 인수를 임의 개수만큼 받으려면 **kwargs를 사용합니다. 전달된 인수는 딕셔너리로 묶입니다.

def show_info(**kwargs):
    print(f"받은 키워드 인수: {kwargs}")
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

show_info(name="Alice", age=25, city="서울")

출력:

받은 키워드 인수: {'name': 'Alice', 'age': 25, 'city': '서울'}
  name: Alice
  age: 25
  city: 서울

매개변수 순서 규칙

파이썬 함수의 매개변수 순서는 다음을 따릅니다:

def func(일반매개변수, *args, 기본값매개변수, **kwargs):
    pass

# 실제 예시
def complex_func(name, *scores, grade="N/A", **extra):
    print(f"이름: {name}")
    print(f"점수들: {scores}")
    print(f"학점: {grade}")
    print(f"기타: {extra}")

complex_func("Alice", 85, 90, 78, grade="B+", school="연세대")

변수의 범위 — 스코프 (Scope)

변수가 접근 가능한 영역을 스코프라고 합니다.

# 전역 변수 (Global Variable)
global_var = "전역"

def my_func():
    # 지역 변수 (Local Variable)
    local_var = "지역"
    print(global_var)    # 전역 변수 접근 가능
    print(local_var)     # 지역 변수 접근 가능

my_func()
print(global_var)   # 전역 변수 접근 가능
# print(local_var)  # NameError — 함수 밖에서 지역 변수 접근 불가

global 키워드

함수 안에서 전역 변수를 수정하려면 global 키워드를 사용합니다.

count = 0

def increment():
    global count   # 전역 변수임을 선언
    count += 1

increment()
increment()
print(count)   # 2

독스트링 (Docstring)

함수 첫 줄에 작성하는 문서화 문자열입니다. help() 함수나 IDE에서 확인할 수 있습니다.

def calculate_bmi(weight, height):
    """
    BMI(체질량지수)를 계산합니다.

    Args:
        weight (float): 체중 (kg)
        height (float): 신장 (m)

    Returns:
        float: BMI 값

    Example:
        >>> calculate_bmi(70, 1.75)
        22.857142857142858
    """
    return weight / (height ** 2)

help(calculate_bmi)   # 독스트링 출력
bmi = calculate_bmi(70, 1.75)
print(f"BMI: {bmi:.2f}")   # BMI: 22.86

람다 함수 (Lambda)

한 줄로 표현하는 익명 함수입니다. 간단한 연산에 활용됩니다.

# 일반 함수
def add(a, b):
    return a + b

# 동일한 람다 함수
add_lambda = lambda a, b: a + b

print(add(3, 5))          # 8
print(add_lambda(3, 5))   # 8

정렬할 때 key로 많이 사용합니다:

students = [("Alice", 90), ("Bob", 75), ("Charlie", 85)]

# 점수(인덱스 1) 기준 정렬
sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_students)
# [('Alice', 90), ('Charlie', 85), ('Bob', 75)]

모듈 (Module)

모듈은 파이썬 코드(함수, 클래스, 변수)가 담긴 .py 파일입니다. import 키워드로 불러옵니다.

import 방법

# 방법 1: 모듈 전체 import
import math
print(math.pi)        # 3.141592653589793
print(math.sqrt(16))  # 4.0

# 방법 2: 특정 이름만 import
from math import pi, sqrt
print(pi)       # 3.141592653589793
print(sqrt(25)) # 5.0

# 방법 3: 별칭(alias) 사용
import math as m
print(m.floor(3.7))   # 3
print(m.ceil(3.2))    # 4

from math import factorial as fac
print(fac(5))    # 120

주요 표준 라이브러리 모듈

모듈	주요 기능
`math`	수학 함수 (sqrt, sin, cos, log, pi 등)
`random`	난수 생성
`datetime`	날짜/시간 처리
`os`	운영체제 인터페이스
`sys`	파이썬 시스템 정보
`re`	정규 표현식
`json`	JSON 데이터 처리
`time`	시간 측정 및 대기

주요 표준 모듈 예시

random 모듈

import random

print(random.random())           # 0.0~1.0 사이 난수
print(random.randint(1, 6))      # 1~6 사이 정수 (주사위)
print(random.choice(["A", "B", "C"]))  # 리스트에서 무작위 선택

numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)          # 리스트 무작위 섞기
print(numbers)

sample = random.sample(range(1, 46), 6)   # 로또 번호 추첨
sample.sort()
print(f"로또 번호: {sample}")

datetime 모듈

from datetime import datetime, date

now = datetime.now()
print(f"현재 날짜·시간: {now}")
print(f"오늘 날짜: {now.strftime('%Y년 %m월 %d일')}")
print(f"현재 시각: {now.strftime('%H시 %M분 %S초')}")

# 날짜 차이 계산
birthday = date(1990, 1, 1)
today = date.today()
diff = today - birthday
print(f"태어난 지 {diff.days}일이 지났습니다.")

os 모듈

import os

print(os.getcwd())              # 현재 작업 디렉토리
print(os.listdir('.'))          # 현재 디렉토리 파일 목록
print(os.path.exists("test.txt"))  # 파일 존재 여부

# 환경 변수
home_dir = os.environ.get("HOME", "알 수 없음")
print(f"홈 디렉토리: {home_dir}")

내 모듈 만들기

자주 쓰는 함수를 모듈로 만들어 재사용할 수 있습니다.

utils.py 파일을 만듭니다:

# utils.py

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

def celsius_to_fahrenheit(c):
    """섭씨를 화씨로 변환"""
    return c * 9/5 + 32

def is_leap_year(year):
    """윤년 여부 판단"""
    return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

PI = 3.14159265358979

같은 디렉토리의 다른 파일에서 불러오기:

# main.py
import utils

print(utils.greet("Alice"))                       # 안녕하세요, Alice님!
print(utils.celsius_to_fahrenheit(100))            # 212.0
print(utils.is_leap_year(2024))                   # True
print(f"원주율: {utils.PI}")

실전 예제 — 성적 관리 프로그램

# grade_manager.py

def get_grade(score):
    """점수를 학점으로 변환"""
    if score >= 90:
        return "A"
    elif score >= 80:
        return "B"
    elif score >= 70:
        return "C"
    elif score >= 60:
        return "D"
    else:
        return "F"

def calculate_average(*scores):
    """평균 계산"""
    if not scores:
        return 0
    return sum(scores) / len(scores)

def print_report(name, **subjects):
    """성적표 출력"""
    print(f"\n{'='*30}")
    print(f"  {name} 성적표")
    print(f"{'='*30}")
    total = 0
    for subject, score in subjects.items():
        grade = get_grade(score)
        print(f"  {subject:8s}: {score:3d}점 ({grade})")
        total += score
    avg = total / len(subjects)
    print(f"{'-'*30}")
    print(f"  평균: {avg:.1f}점 ({get_grade(avg)})")
    print(f"{'='*30}")

print_report("홍길동", 국어=85, 영어=92, 수학=78, 과학=88)

학습 정리

항목	핵심 내용
`def`	함수 정의 키워드
매개변수/인수	정의 시 매개변수, 호출 시 인수
`return`	값 반환, 없으면 None
기본값 매개변수	`def f(a, b=10):`
`*args`	가변 위치 인수 → 튜플
`**kwargs`	가변 키워드 인수 → 딕셔너리
스코프	지역/전역 변수, `global` 키워드
람다	`lambda x: x*2` 한 줄 함수
`import`	모듈 불러오기, from/as 활용

실전 퀴즈 5문항

Q1. 다음 함수를 보고, 함수 호출 결과를 예측하세요.

def calc(a, b=10, c=20):
    return a + b + c

print(calc(5))
print(calc(5, 3))
print(calc(5, c=1))

A1.

calc(5) → 5 + 10 + 20 = 35
calc(5, 3) → 5 + 3 + 20 = 28
calc(5, c=1) → 5 + 10 + 1 = 16

Q2. *args와 **kwargs의 차이를 설명하고, 각각 어떤 자료형으로 저장되는지 답하세요.

A2.

*args: 위치 인수를 가변적으로 받습니다. 전달된 인수들은 **튜플(tuple)**로 저장됩니다.
**kwargs: 키워드 인수를 가변적으로 받습니다. 전달된 인수들은 **딕셔너리(dict)**로 저장됩니다.

Q3. 다음 코드의 출력 결과는 무엇인가요?

def mystery(x, y=2):
    return x ** y

print(mystery(3))
print(mystery(3, 3))
print(mystery(y=4, x=2))

A3.

mystery(3) → 3 ** 2 = 9
mystery(3, 3) → 3 ** 3 = 27
mystery(y=4, x=2) → 2 ** 4 = 16

Q4. import math와 from math import sqrt의 차이점을 설명하고, 각각의 방식으로 루트 25를 계산하는 코드를 작성하세요.

A4.

import math: math 모듈 전체를 가져옵니다. 사용할 때 math.sqrt(25) 처럼 모듈명을 앞에 붙여야 합니다.
from math import sqrt: sqrt 함수만 직접 가져옵니다. sqrt(25) 처럼 바로 사용할 수 있습니다.

import math
print(math.sqrt(25))   # 5.0

from math import sqrt
print(sqrt(25))        # 5.0

Q5. 람다 함수를 사용하여 리스트 words = ["banana", "apple", "cherry", "date"]를 단어 길이 기준으로 오름차순 정렬하는 코드를 작성하세요.

A5.

words = ["banana", "apple", "cherry", "date"]
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)   # ['date', 'apple', 'banana', 'cherry']

lambda x: len(x) 는 각 단어의 길이를 기준값으로 반환하므로 길이 순서대로 정렬됩니다.

OIYO 편집부