7~10주차 — 객체지향 — 클래스와 인스턴스 · 객체지향 — 상속·다형성·매직 메서드 · 정규표현식 · 중급 종합 실습

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount

    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("잔액 부족")
        self.balance -= amount

a = BankAccount("홍길동", 1000)
a.deposit(500); print(f"잔액: {a.balance}")
a.withdraw(800); print(f"잔액: {a.balance}")
try:
    a.withdraw(10000)
except ValueError as e:
    print(f"거부: {e}")

잔액: 1500
잔액: 700
거부: 잔액 부족

class Stack:
    def __init__(self):
        self._items = []

    def push(self, x):
        self._items.append(x)

    def pop(self):
        return self._items.pop()

    def peek(self):
        return self._items[-1] if self._items else None

    def size(self):
        return len(self._items)

    def is_empty(self):
        return len(self._items) == 0

s = Stack()
for x in [1, 2, 3]: s.push(x)
print(f"size={s.size()}")
print(f"peek={s.peek()}")
print(f"pop={s.pop()}")
print(f"size={s.size()}")
print(f"is_empty={s.is_empty()}")

size=3
peek=3
pop=3
size=2
is_empty=False

class Student:
    def __init__(self, name):
        self.name = name
        self.scores = []

    def add_score(self, s):
        self.scores.append(s)

    def average(self):
        return sum(self.scores) / len(self.scores) if self.scores else 0

    def highest(self):
        return max(self.scores) if self.scores else 0

s = Student("홍길동")
for v in [85, 92, 78, 95, 85]: s.add_score(v)
print(f"{s.name}의 평균: {s.average()}")
print(f"최고점: {s.highest()}")

홍길동의 평균: 87.0
최고점: 95

import math

class Shape:
    def area(self):
        return 0

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):
        return self.w * self.h

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

shapes = [Rectangle(10, 20), Circle(5)]
for s in shapes:
    print(f"{type(s).__name__}: {s.area():.2f}")

Rectangle: 200.00
Circle: 78.54

class Playlist:
    def __init__(self, songs=None):
        self.songs = list(songs) if songs else []

    def __len__(self):
        return len(self.songs)

    def __getitem__(self, i):
        return self.songs[i]

    def __add__(self, other):
        return Playlist(self.songs + other.songs)

p1 = Playlist(["봄날", "Spring Day", "FAKE LOVE"])
p2 = Playlist(["DNA", "Butter"])
print(f"len: {len(p1)}")
print(f"첫 곡: {p1[0]}")
print(f"합치기 후 len: {len(p1 + p2)}")

len: 3
첫 곡: 봄날
합치기 후 len: 5

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __sub__(self, other):
        return Vector(self.x - other.x, self.y - other.y)
    def __eq__(self, other):
        return (self.x, self.y) == (other.x, other.y)
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

a = Vector(1, 2)
b = Vector(3, 4)
print(a + b)
print(a - b)
print(a + b == Vector(4, 6))

Vector(4, 6)
Vector(-2, -2)
True

import re

text = """문의는 hong@example.com 또는 kim.young@a.co.kr 로 보내주세요.
긴급은 support+xyz@my-site.io"""

emails = re.findall(r"[\w.+-]+@[\w-]+\.[\w.-]+", text)
print(emails)

['hong@example.com', 'kim.young@a.co.kr', 'support+xyz@my-site.io']

import re

def is_phone(s):
    return bool(re.fullmatch(r"010-\d{4}-\d{4}", s))

for v in ["010-1234-5678", "02-1234-5678", "01012345678"]:
    print(f"{v}: {is_phone(v)}")

010-1234-5678: True
02-1234-5678: False
01012345678: False

import re

log = """INFO 2026-05-09 14:30 서버 시작
ERROR 2026-05-09 14:32 인증 실패
WARN 2026-05-09 14:34 느린 응답
ERROR 2026-05-09 14:35 DB 연결 끊김"""

for line in log.splitlines():
    m = re.match(r"ERROR \d{4}-\d{2}-\d{2} (\d{2}:\d{2}) (.+)", line)
    if m:
        print(f"[{m.group(1)}] {m.group(2)}")

[14:32] 인증 실패
[14:35] DB 연결 끊김

# main.py — 통합 예시
import json, random
from pathlib import Path
from dataclasses import dataclass, field, asdict

PATH = Path("wordbook.json")

@dataclass
class Word:
    en: str
    ko: str
    correct: int = 0
    wrong: int = 0

def load():
    if not PATH.exists(): return []
    return [Word(**w) for w in json.loads(PATH.read_text(encoding="utf-8"))]

def save(words):
    PATH.write_text(json.dumps([asdict(w) for w in words], ensure_ascii=False, indent=2), encoding="utf-8")

def quiz(words):
    if not words: return
    sample = random.sample(words, min(5, len(words)))
    score = 0
    for i, w in enumerate(sample, 1):
        ans = input(f"[{i}/{len(sample)}] {w.en}? ").strip()
        if ans == w.ko:
            print("정답!"); w.correct += 1; score += 1
        else:
            print(f"오답. 정답: {w.ko}"); w.wrong += 1
    print(f"종합: {score}/{len(sample)}")

words = load()
while True:
    cmd = input("> ").strip()
    if cmd == "quit": save(words); break
    elif cmd.startswith("add "):
        en, ko = cmd[4:].split(":"); words.append(Word(en.strip(), ko.strip()))
    elif cmd == "list":
        for i, w in enumerate(words, 1):
            print(f"{i}. {w.en} = {w.ko} (○{w.correct}/×{w.wrong})")
    elif cmd == "quiz": quiz(words)

> add apple:사과
> add book:책
> quiz
[1/2] apple? 사과
정답!
[2/2] book? 가방
오답. 정답: 책
종합: 1/2
> quit

import json
from pathlib import Path
from datetime import date
from dataclasses import dataclass, asdict

PATH = Path("ledger.json")

@dataclass
class Entry:
    type: str
    amount: int
    category: str
    memo: str
    date: str

def load():
    if not PATH.exists(): return []
    return [Entry(**e) for e in json.loads(PATH.read_text(encoding="utf-8"))]

def save(entries):
    PATH.write_text(json.dumps([asdict(e) for e in entries], ensure_ascii=False, indent=2), encoding="utf-8")

def summary(entries):
    inc = sum(e.amount for e in entries if e.type == "수입")
    exp = sum(e.amount for e in entries if e.type == "지출")
    print(f"수입: {inc:,}원")
    print(f"지출: {exp:,}원")
    print(f"잔액: {inc - exp:,}원")
    print("\n[지출 카테고리]")
    cat = {}
    for e in entries:
        if e.type == "지출":
            cat[e.category] = cat.get(e.category, 0) + e.amount
    for k, v in cat.items():
        print(f"{k}: {v:,}원")

entries = load()
while True:
    cmd = input("> ").strip()
    if cmd == "quit": save(entries); break
    elif cmd == "summary": summary(entries)
    elif cmd.startswith("add "):
        t, amt, cat, *memo = cmd[4:].split()
        entries.append(Entry(t, int(amt), cat, " ".join(memo), str(date.today())))

> add 지출 5000 식비 점심
> add 수입 100000 월급
> summary
수입: 100,000원
지출: 5,000원
잔액: 95,000원

[지출 카테고리]
식비: 5,000원

import re, csv
from pathlib import Path

log_text = """INFO 2026-05-09 14:30 서버 시작
ERROR 2026-05-09 14:32 인증 실패
WARN 2026-05-09 14:34 느린 응답
ERROR 2026-05-09 14:35 DB 연결 끊김"""

pattern = re.compile(r"(\w+) \d{4}-\d{2}-\d{2} (\d{2}:\d{2}) (.+)")

rows = []
for line in log_text.splitlines():
    m = pattern.match(line)
    if m:
        rows.append(m.groups())

counts = {}
for level, _, _ in rows:
    counts[level] = counts.get(level, 0) + 1

with open("report.csv", "w", encoding="utf-8", newline="") as f:
    w = csv.writer(f)
    w.writerow(["level", "time", "message"])
    w.writerows(rows)

print(f"처리: {len(rows)}건")
print(", ".join(f"{k}: {v}" for k, v in counts.items()))
print("report.csv 저장됨")

처리: 4건
INFO: 1, ERROR: 2, WARN: 1
report.csv 저장됨