클래스와 객체지향 프로그래밍 기초

1. 객체지향 프로그래밍(OOP)이란

지금까지 배운 방식은 절차적 프로그래밍으로, 코드가 위에서 아래로 실행됩니다. 객체지향 프로그래밍(Object-Oriented Programming, OOP)은 데이터와 그 데이터를 처리하는 함수를 하나의 단위(객체)로 묶는 방식입니다.

# 절차적 방식: 데이터와 함수가 분리되어 있음
name1, age1, score1 = "김민준", 20, 90
name2, age2, score2 = "이수진", 22, 85

def greet(name, age):
    print(f"안녕하세요. {name}({age}세)입니다.")

greet(name1, age1)
greet(name2, age2)
# 학생이 100명이면? 관리가 복잡해짐

# OOP 방식: 데이터 + 함수를 클래스 하나로 묶음
class Student:
    def __init__(self, name, age, score):
        self.name  = name
        self.age   = age
        self.score = score

    def greet(self):
        print(f"안녕하세요. {self.name}({self.age}세)입니다.")

s1 = Student("김민준", 20, 90)
s2 = Student("이수진", 22, 85)
s1.greet()  # → 안녕하세요. 김민준(20세)입니다.
s2.greet()  # → 안녕하세요. 이수진(22세)입니다.

2. 클래스 정의와 인스턴스 생성

# 클래스 = 설계도 / 인스턴스 = 설계도로 만든 실제 객체
# 예: 클래스(붕어빵 틀) → 인스턴스(붕어빵)

class Dog:
    # __init__: 인스턴스 생성 시 자동 호출되는 생성자
    # self: 인스턴스 자신을 가리킴 (첫 번째 인수로 항상 작성)
    def __init__(self, name, breed, age):
        self.name  = name    # 인스턴스 속성(attribute)
        self.breed = breed
        self.age   = age

    # 인스턴스 메서드: 첫 번째 인수가 항상 self
    def bark(self):
        print(f"{self.name}: 왈왈!")

    def info(self):
        print(f"이름: {self.name} | 품종: {self.breed} | 나이: {self.age}살")

    def birthday(self):
        self.age += 1
        print(f"{self.name}의 생일! 이제 {self.age}살입니다.")

# 인스턴스 생성
dog1 = Dog("초코", "말티즈", 3)
dog2 = Dog("바둑", "진돗개", 5)

# 메서드 호출
dog1.bark()     # → 초코: 왈왈!
dog2.info()     # → 이름: 바둑 | 품종: 진돗개 | 나이: 5살
dog1.birthday() # → 초코의 생일! 이제 4살입니다.

# 속성 직접 접근
print(dog1.name)   # → 초코
print(dog2.breed)  # → 진돗개

3. 실전 클래스 예제 — 은행 계좌

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner   = owner
        self.balance = balance
        self.history = []        # 거래 내역 리스트

    def deposit(self, amount):
        if amount <= 0:
            print("입금액은 0보다 커야 합니다.")
            return
        self.balance += amount
        self.history.append(f"입금 +{amount:,}원")
        print(f"입금 완료. 현재 잔액: {self.balance:,}원")

    def withdraw(self, amount):
        if amount > self.balance:
            print("잔액이 부족합니다.")
            return
        self.balance -= amount
        self.history.append(f"출금 -{amount:,}원")
        print(f"출금 완료. 현재 잔액: {self.balance:,}원")

    def show_history(self):
        print(f"\n=== {self.owner}님의 거래 내역 ===")
        for record in self.history:
            print(f"  {record}")
        print(f"현재 잔액: {self.balance:,}원\n")

# 사용
account = BankAccount("김민준", 100000)
account.deposit(50000)     # → 입금 완료. 현재 잔액: 150,000원
account.withdraw(30000)    # → 출금 완료. 현재 잔액: 120,000원
account.withdraw(200000)   # → 잔액이 부족합니다.
account.show_history()

4. 상속(Inheritance)

상속은 기존 클래스(부모)의 속성과 메서드를 물려받아 새 클래스(자식)를 만드는 것입니다. 공통 기능은 부모 클래스에 두고, 자식 클래스에서는 추가·변경만 합니다.

# 부모 클래스 (Animal)
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

    def info(self):
        print(f"이름: {self.name}, 나이: {self.age}살")

    def speak(self):
        print("...")

# 자식 클래스 — Animal을 상속
class Dog(Animal):             # 괄호 안에 부모 클래스 명시
    def speak(self):           # 부모 메서드 오버라이딩(재정의)
        print(f"{self.name}: 왈왈!")

    def fetch(self):           # 자식 클래스만의 새 메서드
        print(f"{self.name}이 공을 가져옵니다!")

class Cat(Animal):
    def speak(self):
        print(f"{self.name}: 야옹~")

    def purr(self):
        print(f"{self.name}이 그루밍 중...")

# 사용
dog = Dog("초코", 3)
cat = Cat("나비", 2)

dog.info()    # 부모 메서드 그대로 사용 → 이름: 초코, 나이: 3살
dog.speak()   # 재정의된 메서드 → 초코: 왈왈!
dog.fetch()   # 자식 전용 메서드 → 초코이 공을 가져옵니다!

cat.info()    # 부모 메서드 → 이름: 나비, 나이: 2살
cat.speak()   # 재정의 → 나비: 야옹~
cat.purr()    # 자식 전용 → 나비이 그루밍 중...

# isinstance(): 인스턴스가 특정 클래스인지 확인
print(isinstance(dog, Dog))     # → True
print(isinstance(dog, Animal))  # → True  (상속 관계도 True)

5. super() — 부모 클래스 접근

# super(): 부모 클래스의 메서드를 호출할 때 사용
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age  = age

class Dog(Animal):
    def __init__(self, name, age, breed):
        super().__init__(name, age)   # 부모 __init__ 호출
        self.breed = breed            # 자식 클래스 추가 속성

    def info(self):
        super().info()               # 부모 info() 호출
        print(f"품종: {self.breed}") # 추가 정보 출력

dog = Dog("초코", 3, "말티즈")
dog.info()
# → 이름: 초코, 나이: 3살
# → 품종: 말티즈

6. 파이썬 입문 완성 — 다음 단계 로드맵

입문 완료 후 방향별 추천 학습 경로:

【 데이터 분석 · AI / ML 】
  → NumPy, Pandas (데이터 처리)
  → Matplotlib, Seaborn (시각화)
  → Scikit-learn (머신러닝)
  → TensorFlow / PyTorch (딥러닝)

【 웹 개발(백엔드) 】
  → Flask (경량 웹 프레임워크, 입문)
  → Django (풀스택 웹 프레임워크)
  → FastAPI (API 서버, 최신 트렌드)

【 자동화 · 스크래핑 】
  → requests + BeautifulSoup (웹 크롤링)
  → Selenium (브라우저 자동화)
  → OpenPyXL (엑셀 자동화)

【 중급 파이썬 】
  → 모듈과 패키지 구조
  → 이터레이터 · 제너레이터
  → 데코레이터(Decorator)
  → 람다(Lambda) · 고차 함수
  → 가상환경(venv) · pip 관리
  → 타입 힌트(Type Hint)

입문 완성 미니 프로젝트 추천:
  1. 숫자 맞추기 게임 (랜덤 모듈 활용)
  2. 가계부 프로그램 (파일 저장)
  3. 학생 성적 관리 시스템 (클래스 활용)
  4. 텍스트 기반 To-Do 앱 (딕셔너리 + 파일)
  5. 간단한 계산기 (함수 + 예외 처리)

관련 검색어  ·  파이썬클래스, OOP파이썬, 파이썬객체지향, __init__self, 파이썬상속, super파이썬, 파이썬입문완성