Python 기초

Python의 객체 지향 프로그래밍

이 레슨에서는 은행 계좌 예제로 Python의 캡슐화, 상속, 메서드 재정의, 다형성을 알아봅니다.

  • 초급
  • 4분 분량
  • 실행 가능한 예제 1개

Python 객체 지향 프로그래밍이란?

어떤 문제를 해결하나요

프로그램이 커지면 여러 곳에서 종류는 같은데 조금씩 다른 객체가 필요해집니다. 일반 계좌와 저축 계좌, 고양이와 개가 그런 예입니다. 클래스를 복사해서 몇 줄만 고치면 코드가 중복됩니다. 곳곳에서 if로 타입을 확인하면 종류가 하나 늘 때마다 여러 곳을 크게 고쳐야 합니다.

일상 속 비유

객체 지향 프로그래밍은 한 은행의 계좌들과 비슷하게 움직입니다. 모든 계좌는 잔액을 창구 안쪽에 보관합니다(캡슐화). 저축 계좌는 일반 계좌에 기능 하나가 더 붙은 것입니다(상속). 은행이 모든 계좌에 '월말'이라고 알리면 계좌마다 자기 방식대로 처리합니다(다형성).

은행에서 코드로
self._balance🔒 창구 안쪽의 돈: deposit()으로만 바꾸기
class SavingsAccount(BankAccount):🏦 저축 계좌는 일반 계좌에 이자를 더한 것
super().__init__(owner, balance)📋 먼저 일반 계좌 양식부터 채우기
account.month_end()📅 같은 요청을 계좌마다 자기 방식대로 처리
공통 규칙은 기본 클래스에, 차이는 하위 클래스에.
한 문장으로

객체 지향 프로그래밍은 프로그램을 클래스 단위로 구성합니다. 클래스로 만든 객체는 자기 데이터를 밖에서 함부로 건드리지 못하게 감추고(캡슐화), 다른 클래스의 코드를 물려받아 쓰며(상속), 같은 호출에 저마다의 방식으로 응답합니다(다형성).

OOP는 협력하는 객체로 시스템을 모델링합니다. 각 객체가 상태와 허용된 연산을 결합하여 큰 프로그램에서도 책임과 변경 경계를 명확하게 합니다.

OOP의 네 가지 핵심 원칙

  • 캡슐화: 상태와 동작을 함께 두고 접근을 제어합니다.
  • 추상화: 필요한 인터페이스를 제공하고 불필요한 구현을 숨깁니다.
  • 상속: 진정한 is-a 관계일 때 기존 클래스를 특수화합니다.
  • 다형성: 서로 다른 객체에 같은 연산을 사용하고 각자의 동작을 실행합니다.

예제 설계

  1. BankAccount가 잔액을 소유하고 입금을 검증합니다.
  2. SavingsAccount가 기본 계약을 재사용합니다.
  3. month_end를 오버라이드해 이자를 적용합니다.
  4. 반복문은 동일한 인터페이스로 모든 계좌를 처리합니다.
설계 팁: 객체가 다른 객체를 단순히 사용한다면 합성을 우선하고, 자식이 부모를 올바르게 대체할 때만 상속을 사용하세요.

언제 사용하나요?

  • 동작이 대부분 같은 여러 종류의 객체: 계좌 종류, 도형, 게임 캐릭터.
  • 나중에 새 종류가 추가되어도 고쳐 쓸 필요 없이 그대로 동작해야 하는 코드.
  • 항상 올바른 상태여야 하는 데이터 보호하기. 예를 들어 잔액은 절대 음수가 되면 안 됩니다.

필요 없는 경우

  • 함수 몇 개로 된 작은 스크립트: 클래스와 상속을 쓰면 필요 없는 구조만 늘어납니다.
  • 깊은 상속 구조(A는 B를, B는 C를, C는 D를 상속): 흐름을 따라가기 어려우므로 합성(composition)을 쓰는 편이 좋습니다.

기본 예제

코드 실행 →
main.py
class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self._balance = float(balance)

    @property
    def balance(self):
        return self._balance

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Deposit must be positive")
        self._balance += amount

    def month_end(self):
        return "No interest"


class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, interest_rate):
        super().__init__(owner, balance)
        self.interest_rate = interest_rate

    def month_end(self):
        self._balance *= 1 + self.interest_rate
        return "Interest applied"


accounts = [
    BankAccount("Ada", 100),
    SavingsAccount("Lin", 200, 0.05),
]
accounts[0].deposit(50)

for account in accounts:
    status = account.month_end()
    print(f"{account.owner}: {account.balance:.2f} ({status})")
이 예제의 실행 버튼 만들기

실행 결과

Ada: 150.00 (No interest)
Lin: 210.00 (Interest applied)

OOP의 네 가지 원칙 실습

이 예제들은 Python에서 캡슐화, 추상화, 상속, 다형성을 일상적인 코드에 적용하는 방법을 보여 줍니다.

캡슐화

코드 실행 →

상태와 동작을 함께 두고 접근을 제어합니다.

encapsulation.py
class BankAccount:
    def __init__(self, balance=0):
        # Double underscores prevent accidental direct access.
        self.__balance = balance

    @property
    def balance(self):
        # Expose read access without exposing mutation.
        return self.__balance

    def deposit(self, amount):
        # Keep validation next to the state it protects.
        if amount <= 0:
            raise ValueError("Amount must be positive")
        self.__balance += amount


account = BankAccount(100)
account.deposit(50)
print(account.balance)  # 150

추상화

코드 실행 →

필요한 인터페이스를 제공하고 불필요한 구현을 숨깁니다.

abstraction.py
from abc import ABC, abstractmethod


class PaymentMethod(ABC):
    @abstractmethod
    def pay(self, amount):
        # Callers know what pay does, not how each provider does it.
        pass


class CreditCard(PaymentMethod):
    def pay(self, amount):
        # The concrete class hides its payment implementation.
        return f"Paid ${amount:.2f} by card"


payment = CreditCard()
print(payment.pay(25))

상속

코드 실행 →

진정한 is-a 관계일 때 기존 클래스를 특수화합니다.

inheritance.py
class Employee:
    def __init__(self, name):
        self.name = name

    def describe(self):
        return self.name


class Developer(Employee):
    def __init__(self, name, language):
        # Reuse initialization from the parent class.
        super().__init__(name)
        self.language = language

    def describe(self):
        # Extend inherited behavior instead of duplicating it.
        return f"{super().describe()} writes {self.language}"


print(Developer("Ada", "Python").describe())

다형성

코드 실행 →

서로 다른 객체에 같은 연산을 사용하고 각자의 동작을 실행합니다.

polymorphism.py
class EmailNotification:
    def send(self, message):
        return f"Email: {message}"


class SmsNotification:
    def send(self, message):
        return f"SMS: {message}"


def notify(channels, message):
    for channel in channels:
        # The same call selects behavior from each concrete object.
        print(channel.send(message))


channels = [EmailNotification(), SmsNotification()]
notify(channels, "Order shipped")

코드 설명

BankAccount 클래스는 잔액을 _balance 속성에 캡슐화하고, deposit() 같은 통제된 메서드를 통해서만 바꿀 수 있게 합니다. SavingsAccount 클래스는 이 메서드들을 모두 물려받고, 이자를 더하도록 month_end()를 재정의합니다. 반복문은 두 계좌에 같은 메서드를 호출하지만, Python은 실행할 때 각 객체 타입에 맞는 버전을 고릅니다. 이것이 바로 다형성입니다.

값을 변경하고 Python 설치 없이 CodeUtility 온라인 Python 컴파일러에서 실행하세요.

연습 문제

아래 제안을 따라 코드를 바꿔 보세요. 코드를 직접 고치고 결과를 확인하면 읽기만 할 때보다 레슨을 훨씬 잘 이해할 수 있습니다.

  1. 입력 데이터를 바꾸고 실행하기 전에 결과를 예상해 보세요.
  2. 비어 있거나 잘못된 데이터를 확인하는 코드를 추가해 보세요.
  3. 처리 부분을 별도의 함수로 분리하고 여러 데이터로 테스트해 보세요.
Python 컴파일러에서 실행 →

자주 하는 실수

super().__init__ 호출 빠뜨리기

이 호출이 없으면 기본 클래스의 초기화 코드가 실행되지 않아 owner 같은 속성이 만들어지지 않습니다.

문제
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        self.interest_rate = rate
수정
class SavingsAccount(BankAccount):
    def __init__(self, owner, balance, rate):
        super().__init__(owner, balance)
        self.interest_rate = rate

보호된 데이터를 직접 바꾸기

밖에서 _balance에 직접 값을 넣으면 deposit() 안의 검사를 거치지 않게 됩니다.

문제
account._balance = -500
수정
account.deposit(50)

이 레슨을 마쳤나요?

학습 완료로 표시하면 진행 상황을 기록할 수 있습니다.

챌린지로 연습하기

이 레슨에서 배운 내용으로 실제 문제를 풀어 보세요. 모든 챌린지는 브라우저에서 실행되며 즉시 테스트와 AI 리뷰를 받을 수 있습니다.

모든 챌린지