7. [파이썬] 함수 기초와 매개변수

💡 본 포스팅은 수업 내용, 교재, ChatGPT를 참고하여 정리한 학습 기록입니다.
글과 그림 등 모든 콘텐츠의 정리 및 작성은 본 블로그에서 직접 제작되었습니다.

 

 

Python 기초부터 Streamlit 데이터 시각화까지 정리하는 학습 기록입니다.

이 글은 '7. [파이썬] 함수 기초와 매개변수' 입니다.

 

 

함수는 파이썬을 배우면서 처음에는 "코드를 묶는 문법" 정도로 보이지만, 조금만 지나면 프로그램을 구조적으로 설계하는 핵심 도구라는 것을 알게 된다.

같은 작업을 반복해서 작성하지 않게 해주고, 입력과 출력을 분리해서 생각하게 만들며, 이후 객체지향이나 모듈화로 넘어갈 때도 가장 중요한 기초가 된다.

 

이번 글에서는 함수의 정의와 호출, 매개변수와 인자, 위치 인자와 키워드 인자, 기본값, 반환값, 가변 인자, 언패킹, 객체 참조 방식, 타입 힌트까지 순서대로 정리해보려고 한다.

 

 

함수란 무엇인가

함수(function)는 '특정 작업을 수행하는 코드의 묶음'이다.

한 번 정의해두면 필요할 때마다 다시 호출해서 사용할 수 있다.

 

아주 기본적인 형태는 다음과 같다.

def show_welcome():
    print("파이썬 학습을 시작합니다.")

show_welcome()
show_welcome()   # 여러번 호출하는 것이 매우 용이하다.

 

실행 결과

파이썬 학습을 시작합니다.
파이썬 학습을 시작합니다.

 

여기서 중요한 흐름은 두 단계이다.

• def 로 함수를 정의(define)한다.
• 함수 이름 뒤에 () 를 붙여 호출한다.

즉, 함수는 만들어두기만 해서는 실행되지 않고, 실제로 호출해야 동작한다.

 

 

함수를 사용하는 이유

함수의 가장 큰 장점은 반복을 줄이고, 의미를 분리해준다는 점이다.

 

예를 들어 점수 데이터를 출력하는 코드가 여러 군데 반복된다면, 매번 print()를 길게 쓰기 보다 함수로 묶는 편이 훨씬 깔끔하다.

def print_score_report():
    print("학습자 점수 리포트")
    print("-" * 20)
    print("출력 완료")

print_score_report()

 

실행 결과

학습자 점수 리포트
--------------------
출력 완료

 

이렇게 함수로 묶어두면 나중에 출력 형식을 바꾸고 싶을 때도 함수 내부만 수정하면 된다.

프로그램이 커질수록 이런 구조화의 효과는 훨씬 커진다.

 

 

매개변수(Parameter)와 인자(Augument)

• 매개변수(parameter): 함수를 정의할 때 선언하는 변수
• 인자(argument): 함수를 호출할 때 실제로 전달하는 값

예제를 보면 차이가 더 분명해진다.

def add_values(x, y):
    print(f"x={x}, y={y}")
    return x + y

print(add_values(10, 5))
print(add_values("data", "base"))

 

실행 결과

x=10, y=5
15
x=data, y=base
database

 

여기서 x, y 는 매개변수이고,

10, 5, "data", "base" 는 인자이다.

 

파이썬 함수는 매우 유연해서 + 연산이 가능한 타입끼리라면 같은 함수에서도 동작할 수 있다.

숫자를 전달하면 덧셈이 되고, 문자열을 전달하면 이어 붙이기가 된다.

이 점이 파이썬의 장점이기도 하지만, 동시에 타입을 정확히 의식하지 않으면 예상치 못한 결과가 나올 수도 있다.

 

 

위치 인자와 키워드 인자

함수를 호출할 때 값을 전달하는 방식은 크게 두 가지 이다.

 

첫 번째는 '위치 인자(positional argument)' 이다.

말 그대로 작성된 순서대로 값이 들어간다.

 

두 번째는 '키워드 인자(keyword argument)' 이다.

매개변수 이름을 직접 지정해서 전달한다.

def introduce(name, role):
    print(f"name={name}, role={role}")

introduce("지은", "data engineer")
introduce(role="backend engineer", name="민수")
introduce("하나", role="analyst")

 

실행 결과

name=지은, role=data engineer
name=민수, role=backend engineer
name=하나, role=analyst

 

여기서 세 번째 호출처럼 위치인자와 키워드 인자를 섞어 쓸 수는 있지만, 규칙이 있다.

항상 위치 인자가 먼저 와야 한다.

 

예를 들어 아래 코드는 문법 오류가 난다.

# introduce(name="지은", "data engineer")

 

즉, 함수 호출에서 값 전달 규칙이 헷갈릴 때는 다음처럼 기억하면 편하다.

• 순서대로 넣으면 위치 인자
• 이름을 지정하면 키워드 인자
• 섞을 때는 위치 인자가 먼저

 

 

기본값이 있는 매개변수

함수는 매개변수에 '기본값(default value)'을 줄 수 있다.

이렇게 하면 호출할 때 인자를 생략해도 함수가 동작한다.

def greet_user(name, message="환영합니다"):
    print(f"{name}님, {message}!")

greet_user("지은")
greet_user("도윤", "오늘도 좋은 하루 보내세요")

 

실행 결과

지은님, 환영합니다!
도윤님, 오늘도 좋은 하루 보내세요!

 

기본값은 매우 자주 쓰인다.

특히 옵션이 많은 함수에서 일부 값만 바꾸고 나머지는 기본 동작을 유지하고 싶을 때 유용하다.

 

다만 중요한 규칙이 하나 있다.

기본값이 있는 매개변수는 반드시 오른쪽에 와야 한다.

 

즉, 아래처럼 쓰면 안 된다.

# def wrong_example(message="안녕", name):
#     print(name, message)

 

이 규칙은 나중에 함수 정의를 읽을 때도 중요하다.

왼쪽에는 보통 필수 입력, 오른쪽에는 선택 입력이 온다고 이해하면 된다.

 

 

반환값(return)의 의미

함수는 단순히 화면에 출력만 하는 것이 아니라, 결과를 호출한 쪽으로 되돌려 줄 수 있다.

그때 사용하는 키워드가 return 이다.

def multiply(a, b):
    return a * b

result = multiply(6, 7)
print(result)

 

실행 결과

42

 

여기서 print() 와 return 의 차이를 분명히 이해해야 한다.

• print() 는 화면에 보여주는 것
• return 은 값을 함수 밖으로 돌려주는 것

즉, 함수 결과를 다른 계산에서 다시 사용하려면 return 이 필요하다.

 

 

여러 개의 값을 한 번에 반환하기

 파이썬에서는 내부적으로 튜플 형태로 묶여 반환된다.

def calc_scores(a, b):
    return a + b, a - b, a * b, a / b

all_result = calc_scores(20, 4)
print(all_result)

plus_result, minus_result, multiply_result, divide_result = calc_scores(20, 4)
print(plus_result)
print(divide_result)

 

실행 결과

(24, 16, 80, 5.0)
24
5.0

 

이처럼 여러 값을 반환하면, 필요한 값만 언패킹해서 사용할 수 있다.

'4. [파이썬] 튜플과 패킹/언패킹'을 읽었다면 이 부분이 자연스럽게 이어진다.

 

 

return을 만나면 함수는 즉시 종료된다

def check_number(n):
    if n > 0:
        return "양수"
    print("이 코드는 n > 0일 때 실행되지 않습니다.")
    return "0 또는 음수"

print(check_number(3))
print(check_number(-1))

 

실행 결과

양수
이 코드는 n > 0일 때 실행되지 않습니다.
0 또는 음수

 

즉, return 아래에 있는 코드가 항상 실행된다고 생각하면 안 된다.

조건문과 함께 쓰일 때는 흐름을 잘 따라가야 한다.

 

 

가변 인자: *args

함수에 전달할 인자의 개수가 매번 달라질 수 있다면 어떻게 해야 할까?

이럴 때 사용하는 것이 가변 인자다.

def collect_numbers(*args):
    print(args)
    print(type(args))

collect_numbers(3)
collect_numbers(3, 6, 9, 12)

 

실행 결과

(3,)
<class 'tuple'>
(3, 6, 9, 12)
<class 'tuple'>

 

*args 는 여러 개의 위치 인자를 '튜플'로 묶어서 받는다.

즉, 인자의 개수가 고정되어 있지 않은 함수에서 매우 유용하다.

 

예를 들어 평균 계산 함수를 만들면 훨씬 자연스럽다.

def get_average(*numbers):
    if not numbers:
        return 0
    return sum(numbers) / len(numbers)

print(get_average(10, 20, 30))
print(get_average(5, 15, 25, 35, 45))
print(get_average())

 

실행 결과

20.0
25.0
0

 

가변 인자는 "입력 개수가 매번 달라지는 함수"를 만들 때 정말 자주 쓰인다.

 

 

가변 키워드 인자: **kwargs

**kwargs 는 여러 개의 키워드 인자를 '딕셔너리'로 묶어서 받는다.

def print_profile(**kwargs):
    print(kwargs)
    print(type(kwargs))

print_profile(name="지은", track="python", level="intermediate")

 

실행 결과

{'name': '지은', 'track': 'python', 'level': 'intermediate'}
<class 'dict'>

 

이 방식은 함수가 다양한 옵션을 받아야 할 때 유용하다.

예를 들어 설정값, 사용자 정보, 필터 조건 등을 유연하게 받고 싶을 때 자주 사용된다.

 

 

*args 와 **kwargs 를 함께 사용하는 함수

둘을 함께 쓰면 매우 유연한 함수를 만들 수 있다.

def log_event(*args, **kwargs):
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

log_event("login")
log_event("purchase", "success", user="user01", amount=32000)

 

실행 결과

args: ('login',)
kwargs: {}
args: ('purchase', 'success')
kwargs: {'user': 'user01', 'amount': 32000}

이런 형태는 지금 단계에서는 조금 추상적으로 보이지만,

나중에 데코레이터나 API 처리, 로깅 함수, 래퍼 함수를 배울 때 매우 자주 보게 된다.

 

 

언패킹으로 함수에 값 전달하기

리스트나 딕셔너리를 풀어서 함수 인자로 전달하는 '언패킹(unpacking)'에 대해 알아보자.

def calculate_total(a, b, c):
    return a + b + c

values = [100, 200, 300]
print(calculate_total(*values))

options = {"a": 7, "b": 8, "c": 9}
print(calculate_total(**options))

 

실행 결과

600
24

 

여기서 핵심은 이것이다.

• *리스트 : 위치 인자로 풀어서 전달
• **딕셔너리 : 키워드 인자로 풀어서 전달

이 개념은 함수 정의에서의 *args, **kwargs 와 연결된다.

 

정리하면 다음과 같다.

• 함수 정의에서 *, ** 는 여러 값을 받기 위한 문법
• 함수 호출에서 *, ** 는 묶인 값을 풀어주기 위한 문법

 

 

데이터 전달 방식: 객체 참조에 의한 전달(Call by Object Reference)

Python은 흔히 "call by value냐, call by reference냐" 같은 질문으로 설명되곤 하지만,

더 정확히는 객체참조(call by object reference, call by sharing) 방식으로 이해하는 편이 좋다.

 

핵심은 이렇다.

• 불변 객체(int, str, tuple 등)는 함수 안에서 값을 다시 대입해도 원본이 바뀌지 않는 것처럼 보인다.
• 가변 객체(list, dict, set 등)는 함수 안에서 내부를 수정하면 원본도 바뀐다.

먼저 불변 객체를 보자.

def change_number(value):
    value = 999

num = 100
change_number(num)
print(num)

 

실행 결과

100

 

이번에는 가변 객체다.

def update_items(items):
    items.append("streamlit")

topics = ["python", "sql"]
update_items(topics)
print(topics)

 

실행 결과

['python', 'sql', 'streamlit']

 

 

이 차이는 이후에 mutable vs immutable, 메모리 구조, 얕은 복사/깊은 복사를 배울 때 매우 중요해진다.

 

 

함수 안에서 원본을 바꾸고 싶지 않을 때

가변 객체를 함수에 넘길 때는 원본이 바뀔 수 있기 때문에 주의가 필요하다.

원본 보호가 필요하다면 복사본을 만들어 처리하는 방법을 많이 쓴다.

def add_subject_safely(subjects):
    copied = subjects.copy()
    copied.append("docker")
    return copied

original_subjects = ["python", "sql"]
new_subjects = add_subject_safely(original_subjects)

print("원본:", original_subjects)
print("새 결과:", new_subjects)

 

실행 결과

원본: ['python', 'sql']
새 결과: ['python', 'sql', 'docker']

 

이처럼 함수가 입력 데이터를 바꾸는지, 아니면 새 결과를 반환하는지에 따라 함수의 성격이 달라진다.

실무에서는 이런 차이가 버그와 직결되는 경우가 잦다고 한다.

 

 

타입 힌트(Type Hint)

Python은 동적 타이핑 언어이기 때문에 변수나 함수가 특정 타입만 강제하는 언어는 아니다.

하지만 타입 힌트를 사용하면 코드의 의도를 더 분명히 드러낼 수 있고, 에디터나 정적 분석 도구의 도움도 받을 수 있다.

def repeat_message(message: str, count: int) -> str:
    return message * count

result = repeat_message("파이썬", 3)
print(result)

 

실행 결과

파이썬파이썬파이썬

 

함수 정의에서 각각 타입 힌트를 정리하면 다음과 같다.

• 매개변수 뒤의 : str, : int
• 함수 선언 뒤의 -> str

기억해야 할 점은 타입 힌트는 가이드일 뿐, 파이썬 인터프리터가 강제하지는 않는다는 점이다.

 

예를 들어 아래 코드는 힌트와 다르게 값을 전달했지만, 문법 자체로는 실행될 수 있다.

def repeat_message(message: str, count: int) -> str:
    return message * count

print(repeat_message(10, 2))

 

실행 결과

20

 

왜 이런 결과가 나올까?

10 * 2 는 파이썬에서 가능한 연산이기 때문이다.

즉, 타입 힌트는 문서를 읽기 쉽게 만들고 도구의 도움을 받게 해주지만, 그 자체가 런타임 강제 규칙은 아니다.

 

 

복잡한 자료형에도 쓸 수 있는 타입 힌트

함수뿐 아니라 변수에도 타입 힌트를 쓸 수있고, 리스트나 딕셔너리 같은 복합 자료형도 표현할 수 있다.

scores: list[int] = [85, 90, 100]
user_info: dict[str, str | int] = {"name": "철수", "age": 36}

print(scores)
print(user_info)

 

실행 결과

[85, 90, 100]
{'name': '철수', 'age': 36}

 

 

매개변수 작성의 중요성

Python 함수의 매개변수는 보통 다음 순서를 많이 따른다.

중급 단계로 갈수록 "어떤 값은 위치로만 받고, 어떤 값은 이름으로만 받게" 설계하는 것이 중요해진다.

아직 너무 깊게 들어갈 필요는 없지만, 아래 예제 정도는 알아두면 좋다.

def create_account(user_id, role="viewer", *, active=True):
    print(f"user_id={user_id}, role={role}, active={active}")

create_account("user01")
create_account("user02", role="editor", active=False)

 

실행 결과

user_id=user01, role=viewer, active=True
user_id=user02, role=editor, active=False

 

여기서 * 뒤에 오는 active 는 키워드로만 전달해야 하는 매개변수다.

이 문법은 라이브러리 함수나 프레임워크 코드에서도 자주 보인다.

 

 

실무 감각으로 보는 함수 설계

좋은 함수는 단순히 "동작하는 함수"가 아니라, 역할이 분명한 함수다.

예를 들어 아래처럼 작성하면 의미가 비교적 분명하다.

def calculate_discounted_price(price, discount_rate=0.1):
    return price * (1 - discount_rate)

final_price = calculate_discounted_price(50000)
vip_price = calculate_discounted_price(50000, 0.2)

print(final_price)
print(vip_price)

 

실행 결과

45000.0
40000.0

 

 

실수하기 쉬운 포인트

첫째, 매개변수와 인자를 혼동하기 쉽다.

함수 정의 쪽에 있는 이름은 매개변수(parameter), 호출 시 실제로 전달하는 값은 인자(argument)다.

 

둘째, print() 와 return 은 다르다.

print() 는 보여주는 것이고, return 은 돌려주는 것이다.

화면에 출력만 되고 변수에 저장되지 않는다면 return을 놓쳤을 가능성이 크다.

 

셋째, 기본값 매개변수는 오른쪽에 와야 한다.

함수 정의 순서를 잘못 쓰면 문법 오류가 난다.

 

넷째, 가변 객체를 함수에 전달하면 원본이 바뀔 수 있다.

특히 리스트, 딕셔너리, 세트는 함수 내부 수정이 원본에 반영될 수 있으니 주의해야 한다.

 

다섯째, *args 는 튜플, **kwargs 는 딕셔너리로 받는다.

정의와 호출에서의 *, ** 역할도 구분해야 한다.

 

여섯째, 타입 힌트는 강제가 아니라 안내다.

힌트를 적었다고 자동으로 타입 오류가 막히는 것은 아니다.

 

 

마무리

함수는 파이썬 문법 중에서도 정말 중요한 전환점이다.

조건문과 반복문까지가 "코드를 순서대로 작성하는 단계"였다면, 함수부터는 "기능을 나누고 재사용하는 단계"로 넘어간다고 볼 수 있다.

 

이번 글에서는 함수의 가장 기본적인 정의와 호출에서 시작해서, 매개변수와 인자, 위치 인자와 키워드 인자, 기본값, 반환값, 여러 값 반환, 가변 인자, 언패킹, 객체 참조 방식, 타입 힌트까지 함께 정리했다.

 

특히 함수는 문법을 외우는 것보다 입력은 무엇이고, 함수가 하는 일은 무엇이며, 결과를 어떻게 돌려주는가를 중심으로 이해하는 것이 중요하다.

 

이 흐름에 익숙해지면 다음에 다룰 함수형 프로그래밍, iterator/generator, 클래스 메소드, 데코레이터 같은 주제도 훨씬 수월하게 받아들일 수 있다.