
Python 기초 — 함수·모듈·객체지향
1. 함수(Function)란 무엇인가
함수(Function)는 특정 작업을 수행하는 코드 블록으로, 이름을 붙여서 필요할 때마다 호출할 수 있습니다.
함수를 사용하면:
- 코드 재사용성 증가 — 같은 코드를 반복 작성하지 않아도 됨
- 가독성 향상 — 코드가 기능 단위로 분리되어 읽기 쉬움
- 유지보수 용이 — 한 곳만 수정하면 전체에 적용
2. 함수 정의와 호출
함수 본문은 들여쓰기로 구분한다. 독스트링은 함수의 첫 문장인 문자열이며, return은 호출자에게 결과를 전달한다. 아래 greet()는 출력만 수행하므로 반환값은 None이다.
# 함수 정의
def greet():
print("안녕하세요!")
print("파이썬에 오신 것을 환영합니다.")
# 함수 호출
greet()
greet() # 몇 번이든 재사용 가능
출력:
안녕하세요!
파이썬에 오신 것을 환영합니다.
안녕하세요!
파이썬에 오신 것을 환영합니다.
3. 매개변수(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
4. 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
5. 기본값 매개변수 (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
가변 기본값이 호출 사이에 남는 이유
기본값 표현식은 함수 호출마다가 아니라 함수 정의 시 평가된다. 기본값으로 리스트를 만들면 호출들이 같은 리스트를 공유할 수 있다. 공식 기본값 인수 설명을 기준으로 객체 생성 시점을 구분한다.
def append_shared(item, items=[]):
items.append(item)
return items
print(append_shared("A"))
print(append_shared("B"))
def append_fresh(item, items=None):
# 2026-10-03: 생략한 호출끼리 리스트를 공유하지 않도록 호출 시 생성한다.
if items is None:
items = []
items.append(item)
return items
print(append_fresh("A"))
print(append_fresh("B"))
출력:
['A']
['A', 'B']
['A']
['B']
None을 쓰는 것은 ‘인수를 생략한 경우마다 새 리스트를 만든다’는 정책이다. 호출자가 직접 리스트를 넘기면 그 리스트를 변경한다. 원본 보존이 계약이라면 list(items)로 복사하는 등 별도의 설계가 필요하며, 얕은 복사는 내부의 가변 객체까지 복제하지 않는다.
6. 키워드 인수 (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)
7. *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
8. **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="연세대")
9. 변수의 범위 — 스코프 (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 선언을 사용한다. 전역 이름이 참조하는 리스트를 append()로 변경하는 것과 이름을 다른 객체로 재바인딩하는 것은 다르다. 바깥 함수의 지역 이름을 재바인딩할 때는 nonlocal을 사용한다. 아래는 전역 재바인딩의 작은 예제이며, 여러 호출자의 상태가 섞이기 쉬운 실무 코드에서는 인수·반환값이나 객체 상태로 의존성을 드러내는 편이 낫다.
count = 0
def increment():
global count # 전역 변수임을 선언
count += 1
increment()
increment()
print(count) # 2
10. 독스트링 (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
11. 람다 함수 (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)]
12. 모듈 (Module)
모듈은 Python 코드의 이름 공간을 제공한다. 여기서는 .py 파일 모듈을 사용하지만, 모든 모듈이 .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 | 시간 측정 및 대기 |
13. 주요 표준 모듈 예시
가. 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}")
14. 내 모듈 만들기
자주 쓰는 함수를 모듈로 만들어 재사용할 수 있습니다.
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}")
import와 직접 실행의 경계
모듈의 최상위 문장은 처음 import할 때도 실행된다. 재사용할 함수 옆에 파일 쓰기나 외부 요청을 그대로 두면, 다른 코드가 import만 해도 부작용이 발생할 수 있다. 직접 실행할 때만 동작할 진입점을 다음처럼 분리한다. 아래는 별도의 example.py 파일로 저장할 예제다.
def main():
print("직접 실행한 진입점")
if __name__ == "__main__":
main()
이 가드는 main() 호출만 조건부로 만든다. 가드 바깥 최상위 코드의 실행을 막거나 프로그램을 보안 격리하지는 않는다. 공식 최상위 실행 환경 문서가 import와 최상위 실행 환경의 차이를 설명한다.
15. 객체지향 — 상태와 연산을 묶는 이유
함수가 입력을 받아 결과를 반환하는 데 적합하다면, 클래스는 여러 연산 동안 유지할 상태와 그 상태를 바꾸는 규칙을 함께 표현하는 데 적합하다. 모든 함수를 클래스로 바꿀 필요는 없다. 상태가 없는 단순 계산은 함수만으로도 충분하다.
| 개념 | 이 장의 예제에서 맡는 역할 |
|---|---|
| 클래스·인스턴스 | BankAccount가 정의이고, Alice의 계좌와 Bob의 계좌는 별도 인스턴스다. |
self·인스턴스 속성 | 메서드를 호출한 계좌의 소유자·잔액을 가리킨다. |
__init__ | 생성된 인스턴스의 초기 상태를 검사하고 설정한다. 생성 자체와 초기화는 구별한다. |
| 메서드 | 입금·출금처럼 상태를 바꾸는 연산에 조건을 둔다. |
| 상속 | 기존 잔액 규칙을 재사용하는 저축 계좌를 정의한다. |
다음은 클래스 학습용 계좌이며 실제 금융 거래를 처리하지 않는다. 일반적인 유한 수치 입력을 가정하고, 초기 잔액은 음수가 아니며 거래 금액은 양수여야 한다. 실패한 입력을 잔액에 반영하지 않는 것이 핵심이다. 클래스 정의와 이어지는 사용 예제는 같은 실행 환경에서 실행한다.
from math import isfinite
class BankAccount:
"""상태 변경 규칙을 연습하기 위한 예제 계좌."""
def __init__(self, owner, balance=0):
if not isfinite(balance) or balance < 0:
raise ValueError("잔액은 유한한 0 이상 수여야 한다.")
self.owner = owner
self.__balance = balance
def deposit(self, amount):
# 2026-10-03: 입력 검사를 상태 변경보다 먼저 해 실패 시 잔액을 보존한다.
if not isfinite(amount) or amount <= 0:
raise ValueError("금액은 유한한 양수여야 한다.")
self.__balance += amount
print(f"입금 {amount:,.2f}, 잔액 {self.__balance:,.2f}")
def withdraw(self, amount):
if not isfinite(amount) or amount <= 0:
raise ValueError("금액은 유한한 양수여야 한다.")
if amount > self.__balance:
print("잔액 부족")
else:
self.__balance -= amount
print(f"출금 {amount:,.2f}, 잔액 {self.__balance:,.2f}")
def get_balance(self):
return self.__balance
def __str__(self):
return f"{self.owner}의 계좌 (잔액 {self.__balance:,.2f})"
account = BankAccount("Alice", 1000)
account.deposit(500)
account.withdraw(300)
print(account)
출력:
입금 500.00, 잔액 1,500.00
출금 300.00, 잔액 1,200.00
Alice의 계좌 (잔액 1,200.00)
__balance의 이중 밑줄은 이름 맹글링으로, 주로 하위 클래스와 이름이 우연히 충돌하는 일을 줄인다. 값을 접근 불가능하게 만드는 보안 장치가 아니다. 이 예제에서는 get_balance()가 지원하는 조회 경로이고 거래 메서드가 변경 규칙을 담당한다. 공식 클래스 문서를 기준으로 ‘private’라는 표현을 절대적인 접근 통제로 해석하지 않는다.
금액에 float를 쓰는 것은 문법을 간단히 보여 주기 위한 선택이다. 실제 금전 시스템에는 정수 최소 단위 또는 십진수 표현, 반올림·범위 제한, 영속 기록·동시성·트랜잭션 규칙이 필요하다. 입력이 유한해도 계산 결과가 범위를 벗어날 수 있으며 이 클래스는 그 검사를 제공하지 않는다. 문자열·불리언 등 임의 입력을 정규화하는 완성된 API도 아니다.
상속과 인스턴스별 상태
class SavingsAccount(BankAccount):
def __init__(self, owner, balance=0, interest_rate=0.03):
super().__init__(owner, balance)
if not isfinite(interest_rate) or interest_rate < 0:
raise ValueError("이율은 유한한 0 이상 수여야 한다.")
self.interest_rate = interest_rate
def add_interest(self):
interest = self.get_balance() * self.interest_rate
if interest > 0:
self.deposit(interest)
print(f"이자 {interest:,.2f}")
savings = SavingsAccount("Bob", 5000, 0.05)
savings.add_interest()
print(savings.get_balance())
print(account.get_balance())
출력:
입금 250.00, 잔액 5,250.00
이자 250.00
5250.0
1200
super().__init__()는 상위 클래스의 초기화 경로를 호출한다. super()의 일반 동작은 메서드 해석 순서를 따르지만, 여기서는 단일 상속만 사용한다. Bob의 상태를 변경해도 Alice의 잔액은 그대로다. self에 속성을 설정했기 때문이다. 클래스 본문에 가변 리스트를 두고 각 인스턴스가 함께 쓰게 만들면 상태가 공유될 수 있으므로, 인스턴스별 목록은 __init__에서 생성한다.
이자는 현재 잔액에 한 번 적용하는 학습 모형이다. 잔액 또는 이율이 0이면 deposit(0)을 호출하지 않으며, 기간·세금·일수 계산·금리 변경은 구현하지 않는다. 상속은 공통 규칙을 재사용하는 선택이지 항상 최선의 구조는 아니다. 계좌에 별도의 이자 계산 정책을 전달하는 합성 방식도 고려할 수 있다.
실패 경계 확인
before = account.get_balance()
for amount in (-10, 0, float("nan"), float("inf")):
try:
account.withdraw(amount)
except ValueError:
assert account.get_balance() == before
account.withdraw(before + 1)
assert account.get_balance() == before
print("실패 입력 뒤 잔액 보존")
출력은 잔액 부족 다음 실패 입력 뒤 잔액 보존이다. 예외는 6장에서 더 다루며, 여기서는 검증이 상태 변경보다 앞서야 한다는 점을 확인한다. assert는 학습용 검증에 사용했다. 최적화 실행에서 빠질 수 있으므로 제품 입력 검사나 보안 규칙을 assert로 대신하지 않는다.
16. 실전 예제 — 성적 관리 프로그램
아래는 0~100점의 유한한 수치로 성적을 요약하는 학습 예제다. 빈 과목 목록은 0점과 다르므로 오류로 처리하고, 출력하기 전에 점수 전체를 검증한다. 성적 저장·동시 편집·학교별 평가 정책은 구현하지 않는다.
# grade_manager.py
from math import isfinite
def validate_score(score):
if isinstance(score, bool) or not isinstance(score, (int, float)):
raise ValueError("점수는 수치여야 한다.")
if not 0 <= score <= 100 or not isfinite(score):
raise ValueError("점수는 유한한 0~100 수여야 한다.")
return score
def get_grade(score):
"""점수를 학점으로 변환"""
validate_score(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:
raise ValueError("빈 점수 목록의 평균은 정의하지 않는다.")
for score in scores:
validate_score(score)
return sum(scores) / len(scores)
def print_report(name, **subjects):
"""성적표 출력"""
# 2026-10-03: 잘못된 입력에서 일부 성적표만 출력하지 않도록 먼저 검증한다.
avg = calculate_average(*subjects.values())
print(f"\n{'='*30}")
print(f" {name} 성적표")
print(f"{'='*30}")
for subject, score in subjects.items():
grade = get_grade(score)
print(f" {subject:8s}: {score:5.1f}점 ({grade})")
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 = 35calc(5, 3)→5 + 3 + 20 = 28calc(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 = 9mystery(3, 3)→3 ** 3 = 27mystery(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 편집부
편집부OIYO 편집부는 경제·법률·생활·자기이해 주제를 1차 자료와 공개 통계로 검증해 정리합니다. 모든 글은 출처 표기와 정기 점검을 거쳐 실용성과 정확성을 함께 유지합니다.