Ver5.0 ๐ Python ๋์์ธ ํจํด๊ณผ ๊ฐ์ฒด์งํฅ ์ค๊ณ ์์น ์ ์ฉ: SOLID๋ถํฐ ํ์ด์ฌ๋ค์ด ํจํด๊น์ง ํ ๋ฒ์ ์ ๋ฆฌํ๊ธฐ

๐ Python ๋์์ธ ํจํด๊ณผ ๊ฐ์ฒด์งํฅ ์ค๊ณ ์์น ์ ์ฉ: SOLID๋ถํฐ ํ์ด์ฌ๋ค์ด ํจํด๊น์ง ํ ๋ฒ์ ์ ๋ฆฌํ๊ธฐ
์ฝ๋๊ฐ 1,000์ค์ ๋์ด๊ฐ๋ ์๊ฐ, "์ด๊ฑฐ ๋๊ฐ ์งฐ๋โฆ" ํ๊ณ ๋ณด๋ ๋ด๊ฐ ์ง ๊ฑฐ์๋ ๊ฒฝํ ์์ง? ์ค๋์ ๊ทธ ๋น๊ทน์ ๋ง์์ฃผ๋ ๋ ๊ฐ์ง ๋ฌด๊ธฐ, ๊ฐ์ฒด์งํฅ ์ค๊ณ ์์น๊ณผ ๋์์ธ ํจํด์ ํ์ด์ฌ ๊ฐ์ฑ์ผ๋ก ์น๊ตฌ์ฒ๋ผ ํ์ด๋ณผ๊ฒ.
๐ฑ 1. ๋์์ธ ํจํด, ๋์ฒด ์ ๋ฐฐ์์ผ ํด?
๋์์ธ ํจํด์ "๋๊ฐ์ ๊ณ ๋ฏผ์ ๋จผ์ ํด๋ณธ ์ ๋ฐฐ๋ค์ ์ ๋ต ๋ ธํธ"์ผ. 1994๋ ์ ์๋ฆฌํ ๊ฐ๋ง, ๋ฆฌ์ฒ๋ ํฌ๋ฆ, ๋ํ ์กด์จ, ์กด ๋ธ๋ฆฌ์๋์ค ๋ค ๋ช ์ด ์ด ์ฑ ใDesign Patterns: Elements of Reusable Object-Oriented Softwareใ๊ฐ ๊ทธ ์ถ๋ฐ์ ์ธ๋ฐ, ์ ์ ๋ค ๋ช ์ ๋ฌถ์ด์ ํํ GoF(Gang of Four)๋ผ๊ณ ๋ถ๋ฌ. ์ด ์ฑ ์ ์ ๋ฆฌ๋ ํจํด์ด ๋ฐ๋ก ์ ๊ทธ๋ฆผ์ 23๊ฐ์ง๊ณ , ๋ชฉ์ ์ ๋ฐ๋ผ ์์ฑ(5)ยท๊ตฌ์กฐ(7)ยทํ์(11) ์ธ ๊ฐ๋๋ก ๋๋์ด.
๊ทผ๋ฐ ์ฌ๊ธฐ์ ์คํด ํ๋ ์ง๊ณ ๊ฐ๊ฒ. ํจํด์ "์ธ์์ ๋ฌด์กฐ๊ฑด ๋ฃ์ด์ผ ํ๋ ๊ณต์"์ด ์๋์ผ. ํจํด์ด ์ง์ง ์ฃผ๋ ๊ฐ์น๋ ๋ ๊ฐ์ง์ผ.
์ฒซ์งธ, ๊ณตํต ์ธ์ด. ๋๋ฃํํ
"์ฌ๊ธฐ ์ ๋ต ํจํด์ผ๋ก ๋ฐ๊พธ์" ํ๋ง๋๋ฉด 10๋ถ์ง๋ฆฌ ์ค๋ช
์ด ๋๋.
๋์งธ, ๋ณ๊ฒฝ์ ๊ฐํ ๊ตฌ์กฐ. ์๊ตฌ์ฌํญ์ ๋ฐ๋์ ๋ฐ๋๋๋ฐ, ํจํด์ ๋๋ถ๋ถ "๋ฐ๋๋ ๋ถ๋ถ๊ณผ ์ ๋ฐ๋๋ ๋ถ๋ถ์ ๋ผ์ด๋๊ธฐ"๋ผ๋ ํ๋์ ์์ด๋์ด๋ก ๊ท๊ฒฐ๋ผ.
โ "๊ตฌํ์ด ์๋๋ผ ์ธํฐํ์ด์ค์ ๋ง์ถฐ ํ๋ก๊ทธ๋๋ฐํ๋ผ."
โก "ํด๋์ค ์์๋ณด๋ค ๊ฐ์ฒด ํฉ์ฑ์ ์ ํธํ๋ผ."
23๊ฐ ํจํด์ ๋ค ๊น๋จน์ด๋ ์ด ๋ ์ค๋ง ๊ธฐ์ตํ๋ฉด ์ ๋ฐ์ ๋จน๊ณ ๋ค์ด๊ฐ๋ ์ ์ด์ผ.
ํ์ด์ฌ์์๋ ํจํด์ด ์ข ๋ค๋ฅด๊ฒ ์๊ฒผ์ด
GoF ์ฑ ์ ์์ ๋ C++๊ณผ ์ค๋ชฐํ ํฌ๋ก ์ฐ์์ด. ์ ์ ํ์ ์ธ์ด์์๋ "ํจ์๋ฅผ ๊ฐ์ฒ๋ผ ๋๊ธฐ๊ธฐ"๋ "๋ฐํ์์ ํด๋์ค ๋ฐ๊พธ๊ธฐ"๊ฐ ์ด๋ ค์์ ์ด๋ฅผ ์ฐํํ๋ ค๊ณ ํด๋์ค๋ฅผ ์ฌ๋ฌ ๊ฐ ๋ง๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์ง. ๊ทธ๋ฐ๋ฐ ํ์ด์ฌ์ ํจ์๊ฐ ์ผ๊ธ ๊ฐ์ฒด์ด๊ณ , ๋ ํ์ดํ์ ์ฐ๊ณ , ๋ชจ๋ ์์ฒด๊ฐ ๊ฐ์ฒด์ผ. ๊ทธ๋์ ์ด๋ค ํจํด์ ํด๋์ค ๋ค์ฏ ๊ฐ ๋์ ํจ์ ํ๋๋ก ๋๋๊ธฐ๋ ํด.
๊ตฌ๊ธ ์ฐ๊ตฌ ๋๋ ํฐ์๋ ํผํฐ ๋ ธ๋น (Peter Norvig)์ 1996๋ ๋ฐํ ์๋ฃ ใDesign Patterns in Dynamic Languagesใ์์ GoF 23๊ฐ ํจํด ์ค 16๊ฐ๊ฐ ๋์ ์ธ์ด(๋ฆฌ์คํยท๋๋ฐ)์์๋ ๋ณด์ด์ง ์๊ฑฐ๋ ๋ ๋จ์ํด์ง๋ค๊ณ ์ ๋ฆฌํ์ด. ํ์ด์ฌ๋ ๊ฐ์ ๋์ ์ธ์ด ๊ณ์ด์ด๋๊น, ์ด ๊ธ์์๋ "๊ต๊ณผ์ ๋ฒ์ "๊ณผ "ํ์ด์ฌ๋ค์ด ๋ฒ์ "์ ๋๋ํ ๋น๊ตํ๋ฉด์ ๊ฐ ๊ฑฐ์ผ.
๐งฌ 2. ํจํด ์ด์ ์ ๊ธฐ์ด ์ฒด๋ ฅ: ํ์ด์ฌ ๊ฐ์ฒด์งํฅ 4๋ ๊ธฐ๋ฅ
ํจํด์ ๊ฒฐ๊ตญ ๊ฐ์ฒด์งํฅ์ ์์ฉ์ด๋ผ, ํ์ด์ฌ์ด ๊ฐ์ฒด์งํฅ์ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ง์ํ๋์ง๋ถํฐ ์ ํํ ์์์ผ ํด. ๋ค๋ฅธ ์ธ์ด์์ ๋์ด์จ ์ฌ๋๋ค์ด ์ฌ๊ธฐ์ ์ ์ผ ๋ง์ด ํท๊ฐ๋ ค.
_name์ "๋ด๋ถ์ฉ์ด๋ ๊ฑด๋๋ฆฌ์ง ๋ง" ๊ด๋ก, __name์ ์ด๋ฆ ๋งน๊ธ๋ง์ผ๋ก ์ถฉ๋ ๋ฐฉ์ง. ๋์ @property๋ก ์ ๊ทผ์ ํต์ ํด.super()๋ "๋ถ๋ชจ"๊ฐ ์๋๋ผ "MRO์ ๋ค์ ํด๋์ค"์ผ.abc ๋ชจ๋์ ABC์ @abstractmethod๋ก ๋ช
์์ ๊ณ์ฝ์, typing.Protocol(PEP 544, ํ์ด์ฌ 3.8+)๋ก ๊ตฌ์กฐ์ ๊ณ์ฝ์ ํํํด.์บก์ํ: "์ฐ๋ฆฌ๋ ๋ชจ๋ ์ฑ์ธ์ด๋ค"
ํ์ด์ฌ ์ปค๋ฎค๋ํฐ์๋ "We are all consenting adults here"๋ผ๋ ์ ๋ช ํ ๋ง์ด ์์ด. ์ธ์ด๊ฐ ๊ฐ์ ๋ก ๋ง๊ธฐ๋ณด๋ค๋ ๊ด๋ก๋ก ์ฝ์ํ์๋ ์ฒ ํ์ด์ง. ์ค์ ๋์์ ํ์ธํด ๋ณผ๊น?
class Account:
def __init__(self, owner, balance=0):
self.owner = owner
self._history = [] # ๊ด๋ก์ ๋ด๋ถ์ฉ
self.__balance = balance # ์ด๋ฆ ๋งน๊ธ๋ง ๋์
@property
def balance(self):
return self.__balance
def deposit(self, amount):
if amount <= 0:
raise ValueError("์
๊ธ์ก์ 0๋ณด๋ค ์ปค์ผ ํด์")
self.__balance += amount
self._history.append(("deposit", amount))
acc = Account("๋ฏผ์ง", 1000)
acc.deposit(500)
print(acc.balance) # 1500
# acc.balance = 0 # AttributeError: setter๊ฐ ์์ด์ ๋งํ
print(acc._Account__balance) # 1500 โ ๋งน๊ธ๋ง๋ ์ด๋ฆ์ผ๋ก๋ ์ ๊ทผ ๊ฐ๋ฅ
๋ง์ง๋ง ์ค ๋ณด์ด์ง? __balance๋ ๋ด๋ถ์ ์ผ๋ก _Account__balance๋ก ์ด๋ฆ์ด ๋ฐ๋ ๋ฟ, ์ง์ง๋ก ์จ๊ฒจ์ง์ง ์์. ์ด๋ฆ ๋งน๊ธ๋ง์ ์๋ ๋ชฉ์ ์ ๋ณด์์ด ์๋๋ผ ํ์ ํด๋์ค์์ ์ด๋ฆ ์ถฉ๋ ๋ฐฉ์ง์ผ. ๊ทธ๋ฌ๋๊น "์ธ๋ถ์ ๋
ธ์ถํ ๊ฐ์ property๋ก, ๋ด๋ถ์ฉ์ ์ธ๋์ค์ฝ์ด ํ๋๋ก"๊ฐ ๊ฐ์ฅ ๋ฌด๋ํ ์ต๊ด์ด์ผ.
์์๊ณผ MRO: ๋ค์ด์๋ชฌ๋ ์์์ ์ด๋ ๊ฒ ํ๋ฆฐ๋ค
๋ค์ค ์์์์ ๊ฐ์ ์กฐ์์ ๋ ๋ฒ ๋ฌผ๋ ค๋ฐ๋ "๋ค์ด์๋ชฌ๋" ๊ตฌ์กฐ๊ฐ ์๊ธฐ๋ฉด, ๋ฉ์๋๋ฅผ ์ด๋์๋ถํฐ ์ฐพ์์ง ์์๊ฐ ํ์ํด. ํ์ด์ฌ์ 2.3 ๋ฒ์ ๋ถํฐ ์ ์คํ์ผ ํด๋์ค์ C3 ์ ํํ๋ฅผ ์ ์ฉํด์ ์ด ์์(MRO, Method Resolution Order)๋ฅผ ๊ณ์ฐํด.
class A:
def hello(self):
return "A"
class B(A):
def hello(self):
return "B โ " + super().hello()
class C(A):
def hello(self):
return "C โ " + super().hello()
class D(B, C):
def hello(self):
return "D โ " + super().hello()
print(D().hello()) # D โ B โ C โ A
print([k.__name__ for k in D.__mro__])
# ['D', 'B', 'C', 'A', 'object']
์ฌ๋ฐ๋ ํฌ์ธํธ! B์ super().hello()๋ B์ ๋ถ๋ชจ์ธ A๊ฐ ์๋๋ผ C๋ฅผ ๋ถ๋ฌ. super()๋ "MRO์ ๋ด ๋ค์ ๋
์"์ ๊ฐ๋ฆฌํค๊ธฐ ๋๋ฌธ์ด์ผ. ์ด ๋๋ถ์ A๊ฐ ๋ฑ ํ ๋ฒ๋ง ํธ์ถ๋๋ ํ๋ ฅ์ ๋ค์ค ์์(cooperative multiple inheritance)์ด ๊ฐ๋ฅํด. ๋ฏน์ค์ธ(Mixin) ํด๋์ค๋ฅผ ์กฐํฉํ๋ Django์ ํด๋์ค ๊ธฐ๋ฐ ๋ทฐ ๊ฐ์ ๊ตฌ์กฐ๊ฐ ๋ฐ๋ก ์ด ์๋ฆฌ ์์์ ๋์๊ฐ.
๋คํ์ฑ๊ณผ ์ถ์ํ: ABC vs Protocol
ํ์ด์ฌ์์ "์ด ๊ฐ์ฒด๋ ์ด๋ฐ ๋ฉ์๋๋ฅผ ๊ฐ์ ธ์ผ ํด"๋ผ๋ ๊ณ์ฝ์ ํํํ๋ ๋ฐฉ๋ฒ์ ํฌ๊ฒ ๋ ๊ฐ์ง์ผ.
from abc import ABC, abstractmethod
from typing import Protocol
# ๋ฐฉ๋ฒ 1: ๋ช
์์ ์์(๋ช
๋ชฉ์ ํ์ดํ)
class Shape(ABC):
@abstractmethod
def area(self) -> float: ...
class Circle(Shape):
def __init__(self, r): self.r = r
def area(self): return 3.14159 * self.r ** 2
# Shape() โ TypeError: ์ถ์ ๋ฉ์๋๊ฐ ์์ด ์ธ์คํด์คํ ๋ถ๊ฐ
# ๋ฐฉ๋ฒ 2: ๊ตฌ์กฐ์ ํ์ดํ(์์ ๋ถํ์)
class Drawable(Protocol):
def draw(self) -> str: ...
class Button: # Drawable์ ์์ํ์ง ์์!
def draw(self): return "[๋ฒํผ]"
def render(item: Drawable) -> None:
print(item.draw())
render(Button()) # mypy ๊ฐ์ ํ์
๊ฒ์ฌ๊ธฐ๋ ํต๊ณผ
Protocol์ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํด๋์ค์ฒ๋ผ ๋ด๊ฐ ์์ ๊ตฌ์กฐ๋ฅผ ๊ฑด๋๋ฆด ์ ์๋ ๋์๊น์ง ํฌ๊ดํ๊ณ ์ถ์ ๋ ๊ฐ๋ ฅํด. ๊ธฐ๋ณธ์ ์ผ๋ก๋ ์ ์ ํ์ ๊ฒ์ฌ์ฉ์ด๊ณ , ๋ฐํ์
isinstance ๊ฒ์ฌ๊ฐ ํ์ํ๋ฉด @runtime_checkable์ ๋ถ์ฌ์ผ ํด(์ด๋๋ ๋ฉ์๋ ์กด์ฌ ์ฌ๋ถ๋ง ํ์ธํ๊ณ ์๊ทธ๋์ฒ๊น์ง๋ ๊ฒ์ฌํ์ง ์์).
๐๏ธ 3. SOLID ์์น, ํ์ด์ฌ ์ฝ๋๋ก ํ๋์ฉ ๋ฏ์ด๋ณด๊ธฐ
SOLID๋ ๋ก๋ฒํธ C. ๋งํด(์ผ๋ช ์ํด ๋ฐฅ)์ด ์ ๋ฆฌํ ๋ค์ฏ ๊ฐ์ง ์ค๊ณ ์์น์ด๊ณ , ์ ๊ธ์๋ฅผ ๋ฐ์ SOLID๋ผ๋ ์ด๋ฆ์ ๋ถ์ธ ์ฌ๋์ ๋ง์ดํด ํ๋์ค์ผ. ํจํด์ด "๊ตฌ์ฒด์ ํด๋ฒ"์ด๋ผ๋ฉด SOLID๋ "์ข์ ํด๋ฒ์ธ์ง ํ๋จํ๋ ๊ธฐ์ค"์ด์ผ. ํ๋์ฉ ๋์ ์ โ ์ข์ ์๋ก ๊ฐ๋ณผ๊ฒ.
S โ ๋จ์ผ ์ฑ ์ ์์น(SRP)
"ํ ํด๋์ค๋ ํ ๊ฐ์ง ์ผ๋ง"์ด๋ผ๊ณ ๋ง์ด ์ธ์ฐ๋๋ฐ, ๋งํด ๋ณธ์ธ์ "๋ณ๊ฒฝ์ ์ด์ ๊ฐ ํ๋"๋ผ๋ ํํ์ ๋ ๊ฐ์กฐํด. ์ฆ, ์ด ํด๋์ค๋ฅผ ๊ณ ์ณ๋ฌ๋ผ๊ณ ์์ฒญํ ์ฌ๋(๋๋ ๋ถ์)์ด ํ ๊ณณ์ด์ด์ผ ํ๋ค๋ ๊ฑฐ์ง.
class Report:
def __init__(self, data):
self.data = data
def calculate(self): # ๊ธฐํํ ์๊ตฌ
return sum(self.data)
def to_html(self): # ๋์์ธํ ์๊ตฌ
return f"<p>{self.calculate()}</p>"
def save(self, path): # ์ธํ๋ผํ ์๊ตฌ
with open(path, "w") as f:
f.write(self.to_html())class Report:
def __init__(self, data):
self.data = data
def total(self):
return sum(self.data)
class HtmlFormatter:
def format(self, report):
return f"<p>{report.total()}</p>"
class FileStorage:
def save(self, text, path):
with open(path, "w") as f:
f.write(text)์ด์ ๋์์ธํ์ด "PDF๋ก๋ ๋ฝ์์ค" ํ๋ฉด PdfFormatter๋ง ์ถ๊ฐํ๋ฉด ๋๊ณ , ๊ณ์ฐ ๋ก์ง์ ์๋ ํ์๊ฐ ์์ด. ๋จ, ํ์ด์ฌ์์๋ ํด๋์ค๋ฅผ ๊ณผํ๊ฒ ์ชผ๊ฐ๋ ๊ฒ๋ ๋
์ด์ผ. ๋ชจ๋ ์์ค ํจ์ ํ๋๋ก ์ถฉ๋ถํ ๊ฑธ ๊ตณ์ด ํด๋์ค๋ก ๊ฐ์ ํ์๋ ์์ด.
O โ ๊ฐ๋ฐฉ-ํ์ ์์น(OCP)
์ ๊ธฐ๋ฅ์ ๋ฃ์ ๋๋ง๋ค ๊ธฐ์กด ํจ์์ if/elif๋ฅผ ๋ง๋ถ์ด๊ณ ์๋ค๋ฉด OCP ์๋ฐ์ ๋์๊ฐ ๋๋ ๊ฑฐ์ผ.
# โ ํ ์ธ ์ข
๋ฅ๊ฐ ๋ ๋๋ง๋ค ์ด ํจ์๋ฅผ ์์ ํด์ผ ํจ
def discount(kind, price):
if kind == "student":
return price * 0.8
elif kind == "vip":
return price * 0.7
# ์ ๋ฑ๊ธ ์ถ๊ฐ = ๊ธฐ์กด ์ฝ๋ ์์ ...
# โ
๋ฑ๋ก๋ถ(๋ ์ง์คํธ๋ฆฌ)๋ก ํ์ฅ์ ์ด๊ธฐ
DISCOUNTS = {}
def register(kind):
def deco(func):
DISCOUNTS[kind] = func
return func
return deco
@register("student")
def student(price): return price * 0.8
@register("vip")
def vip(price): return price * 0.7
@register("employee") # ์ ๊ธฐ๋ฅ: ๊ธฐ์กด ์ฝ๋ ์์ ์์ด ์ถ๊ฐ!
def employee(price): return price * 0.5
def discount(kind, price):
return DISCOUNTS[kind](price)
ํ์ด์ฌ์์๋ ์ด "๋ฐ์ฝ๋ ์ดํฐ + ๋์
๋๋ฆฌ ๋ ์ง์คํธ๋ฆฌ" ์กฐํฉ์ด OCP๋ฅผ ๊ตฌํํ๋ ์์ฃผ ํํ ๊ด์ฉ๊ตฌ์ผ. Flask์ @app.route, pytest์ ํ๋ฌ๊ทธ์ธ ํ
๊ฐ์ ๊ฒ๋ค์ด ๊ฐ์ ๊ณ์ด์ ์์ด๋์ด๋ผ๊ณ ๋ณด๋ฉด ๋ผ.
L โ ๋ฆฌ์ค์ฝํ ์นํ ์์น(LSP)
๋ฐ๋ฐ๋ผ ๋ฆฌ์ค์ฝํ๊ฐ 1987๋ ๋ฐํ์์ ์ ์ํ ์์น์ด์ผ. ํต์ฌ์ "ํ์ ํ์ ์ ์์ ํ์ ์ ์ฝ์์ ๊นจ๋ฉด ์ ๋๋ค". ์ ๋ช ํ ์ฌ๊ฐํ-์ ์ฌ๊ฐํ ๋ฌธ์ ๋ฅผ ๋ณด์.
class Rectangle:
def __init__(self, w, h):
self.w, self.h = w, h
def set_width(self, w):
self.w = w
def area(self):
return self.w * self.h
class Square(Rectangle):
def __init__(self, size):
super().__init__(size, size)
def set_width(self, w): # ์ ์ฌ๊ฐํ์ด๋ ๋์ด๋ ๊ฐ์ด ๋ฐ๊ฟ
self.w = self.h = w
def stretch(rect: Rectangle):
rect.set_width(10)
assert rect.area() == 10 * rect.h # ํต๊ณผ๋ ํ์ง๋ง...
r = Rectangle(2, 5); stretch(r); print(r.area()) # 50 (๋์ด 5 ์ ์ง)
s = Square(5); stretch(s); print(s.area()) # 100 (๋์ด๊น์ง ๋ฐ๋!)
"๋๋น๋ง ๋ฐ๊พธ๋ฉด ๋์ด๋ ๊ทธ๋๋ก"๋ผ๋ Rectangle์ ์๋ฌต์ ์ฝ์์ Square๊ฐ ๊นจ๋ฒ๋ ธ์ด. ์ํ์ ์ผ๋ก๋ ์ ์ฌ๊ฐํ์ด ์ง์ฌ๊ฐํ์ ์ผ์ข
์ด์ด๋, ํ์(๋์) ๊ด์ ์์๋ is-a ๊ด๊ณ๊ฐ ์๋ ๊ฑฐ์ง. ํด๊ฒฐ์ฑ
์ ๋ ๋ค Shape๋ฅผ ๋ฐ๋ก ๊ตฌํํ๊ฒ ํ๊ฑฐ๋, ํฌ๊ธฐ๋ฅผ ๋ฐ๊พธ๋ ๋์ ์ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๋ถ๋ณ(immutable) ์ค๊ณ๋ก ๊ฐ๋ ๊ฑฐ์ผ.
raise NotImplementedError๋ฅผ ๋์ง๋ ๊ฒฝ์ฐ("๋๋ ์ด ๊ธฐ๋ฅ ์ง์ ์ ํด")โก ๋ถ๋ชจ๋ณด๋ค ๋ ์ข์ ์ธ์๋ฅผ ๋ฐ๊ฑฐ๋(์ ์ ์กฐ๊ฑด ๊ฐํ), ๋ค๋ฅธ ํ์ ์ ๋ฐํํ๋ ๊ฒฝ์ฐ
โข ๋ถ๋ชจ๋ ์ ๋์ง๋ ์์ธ๋ฅผ ์๋ก ๋์ง๋ ๊ฒฝ์ฐ
์ด๋ฐ ๊ฒ ๋ณด์ด๋ฉด ์์ ๊ตฌ์กฐ ์์ฒด๋ฅผ ๋ค์ ์์ฌํด๋ด์ผ ํด.
I โ ์ธํฐํ์ด์ค ๋ถ๋ฆฌ ์์น(ISP)
"๋ค๊ธฐ๋ฅ ๋ณตํฉ๊ธฐ ์ธํฐํ์ด์ค"๋ฅผ ๋ง๋ค๋ฉด, ๊ทธ๋ฅ ํ๋ฆฐํฐ๋ ์ธ๋ฐ์๋ ์ค์บยทํฉ์ค ๋ฉ์๋๊น์ง ๋ ์๊ฒ ๋ผ. ํ์ด์ฌ์์๋ Protocol์ ์๊ฒ ์ชผ๊ฐ๋ ๊ฒ ๊ฐ์ฅ ์์ฐ์ค๋ฌ์.
from typing import Protocol
class Printer(Protocol):
def print_doc(self, doc: str) -> None: ...
class Scanner(Protocol):
def scan(self) -> str: ...
class SimplePrinter:
def print_doc(self, doc): print("์ถ๋ ฅ:", doc)
class MultiFunction:
def print_doc(self, doc): print("์ถ๋ ฅ:", doc)
def scan(self): return "์ค์บ ๋ฐ์ดํฐ"
def office_print(p: Printer, doc: str): # ์ถ๋ ฅ ๊ธฐ๋ฅ๋ง ์๊ตฌ
p.print_doc(doc)
office_print(SimplePrinter(), "๋ณด๊ณ ์") # OK
office_print(MultiFunction(), "๋ณด๊ณ ์") # OK
ํ์ด์ฌ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ collections.abc๋ฅผ ๋ณด๋ฉด ์ด ์์น์ด ์ ๋๋ฌ๋. Iterable(__iter__๋ง), Sized(__len__๋ง), Container(__contains__๋ง)์ฒ๋ผ ์์ฃผ ์์ ์ถ์ ํด๋์ค๋ค์ด ์๊ณ , ์ด๊ฑธ ์กฐํฉํ ๊ฒ Collection์ด์ผ. ์๊ฒ ์ชผ๊ฐ๊ณ ์กฐํฉํ๋ ๊ฑฐ, ๊ทธ๊ฒ ISP์ผ.
D โ ์์กด์ฑ ์ญ์ ์์น(DIP)
์์ ์ ์ฑ (๋น์ฆ๋์ค ๋ก์ง)์ด ํ์ ์ธ๋ถ์ฌํญ(MySQL, ํน์ API)์ ์ง์ ์์กดํ๋ฉด, DB ํ๋ ๋ฐ๊พธ๋ ๋ฐ ๋น์ฆ๋์ค ์ฝ๋๋ฅผ ๋ค ๋ฏ์ด์ผ ํด. ๋ ๋ค "์ถ์"์ ์์กดํ๊ฒ ๋ค์ง๋ ๊ฒ DIP์ผ.
from typing import Protocol
class UserRepository(Protocol):
def find(self, user_id: int) -> dict | None: ...
class PostgresUserRepo:
def find(self, user_id):
... # ์ค์ DB ์กฐํ
class InMemoryUserRepo:
def __init__(self, users): self.users = users
def find(self, user_id): return self.users.get(user_id)
class UserService:
def __init__(self, repo: UserRepository): # ์์ฑ์ ์ฃผ์
self.repo = repo
def greet(self, user_id):
user = self.repo.find(user_id)
return f"์๋
, {user['name']}!" if user else "๋๊ตฌ์ธ์?"
# ํ
์คํธ์์๋ DB ์์ด ๋ฐ๋ก ๊ฒ์ฆ ๊ฐ๋ฅ
svc = UserService(InMemoryUserRepo({1: {"name": "์งํ"}}))
print(svc.greet(1)) # ์๋
, ์งํ!
์ด๊ฒ ๋ฐ๋ก ์์กด์ฑ ์ฃผ์
(DI)์ด์ผ. ํ์ด์ฌ์ DI ํ๋ ์์ํฌ ์์ด๋ ์์ฑ์ ์ธ์ ํ๋๋ก ์ถฉ๋ถํ ๊ตฌํ๋ผ. FastAPI์ Depends๋ ์ด ์์ด๋์ด๋ฅผ ํ๋ ์์ํฌ ์ฐจ์์์ ์ ๊ณตํ๋ ๊ฑฐ๊ณ . ์ฐธ๊ณ ๋ก ์ ์ฝ๋์ dict | None ๋ฌธ๋ฒ์ ํ์ด์ฌ 3.10๋ถํฐ ์ง์๋ผ.
๐งฑ 4. ์์ฑ ํจํด: ๊ฐ์ฒด๋ฅผ "์ด๋ป๊ฒ" ๋ง๋ค๊น
์์ฑ ํจํด์ ๊ฐ์ฒด ์์ฑ ๋ก์ง์ ์ฌ์ฉํ๋ ์ชฝ ์ฝ๋๋ก๋ถํฐ ๋ผ์ด๋ด๋ ํจํด๋ค์ด์ผ. new ํค์๋๊ฐ ์๋ ํ์ด์ฌ์์๋ ์์ฑ ์์ฒด๊ฐ ํจ์ ํธ์ถ(ClassName())์ด๋ผ, ์ฌ๊ธฐ์๋ถํฐ ํ์ด์ฌ๋ค์ด ๋จ์ํ๊ฐ ๋น์ ๋ฐํด.
์ฑ๊ธํด(Singleton): ์ธ์์ ๋จ ํ๋๋ฟ์ธ ๊ฐ์ฒด
์ค์ , ๋ก๊ฑฐ, ์ปค๋ฅ์ ํ์ฒ๋ผ ํ๋ก๊ทธ๋จ ์ ์ฒด์์ ๋ฑ ํ๋๋ง ์์ด์ผ ํ๋ ๊ฐ์ฒด์ ์ฐ๋ ํจํด์ด์ผ. ํ์ด์ฌ์์๋ ๋ฐฉ๋ฒ์ด ์ฌ๋ฌ ๊ฐ๋ผ์ ์คํ๋ ค ํท๊ฐ๋ฆฌ์ง. ๋น๊ตํด ๋ณด์.
# ๋ฐฉ๋ฒ 1: __new__ ์ค๋ฒ๋ผ์ด๋
class Config:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
a, b = Config(), Config()
print(a is b) # True
# ๋ฐฉ๋ฒ 2: ๋ฉํํด๋์ค
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super().__call__(*args, **kwargs)
return cls._instances[cls]
class Logger(metaclass=SingletonMeta):
def __init__(self):
print("๋ก๊ฑฐ ์ด๊ธฐํ") # ๋ฑ ํ ๋ฒ๋ง ์ถ๋ ฅ๋จ
Logger(); Logger()
Config()๋ฅผ ํธ์ถํ ๋๋ง๋ค __init__์ด ๋ค์ ์คํ๋ผ. ์ด๊ธฐํ ์ฝ๋์์ ๊ฐ์ ๋ฎ์ด์ฐ๋ฉด ๊ธฐ์กด ์ํ๊ฐ ๋ ์๊ฐ์ง. ๋ฉํํด๋์ค ๋ฐฉ์์ __call__ ๋จ๊ณ์์ ๋ง๊ธฐ ๋๋ฌธ์ __init__์ด ํ ๋ฒ๋ง ๋์. ๋ ๋ ๋ฐฉ์ ๋ชจ๋ ๋ฉํฐ์ค๋ ๋ ํ๊ฒฝ์์ ๋์์ ์ฒซ ์์ฑ์ด ์ผ์ด๋๋ฉด ์ธ์คํด์ค๊ฐ ๋ ์๊ธธ ์ ์์ด์, ์๊ฒฉํ ํ์ํ๋ฉด threading.Lock์ผ๋ก ๊ฐ์ธ์ผ ํด.
๊ทธ๋ฐ๋ฐ ์ฌ์ค ๊ฐ์ฅ ํ์ด์ฌ๋ค์ด ์ฑ๊ธํด์ "๋ชจ๋"์ด์ผ. ํ์ด์ฌ์ ๋ชจ๋์ ์ฒ์ importํ ๋ ํ ๋ฒ ์คํํ๊ณ sys.modules์ ์บ์ํด์, ์ดํ import๋ ๊ฐ์ ๋ชจ๋ ๊ฐ์ฒด๋ฅผ ๋๋ ค์ฃผ๊ฑฐ๋ .
# settings.py
DEBUG = False
DB_URL = "postgresql://localhost/app"
# ์ด๋์๋
import settings
settings.DEBUG = True # ๋ชจ๋ ๊ณณ์์ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ณต์
ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ logging.getLogger(name)๋ ๊ฐ์ ์ด๋ฆ์ด๋ฉด ๊ฐ์ ๋ก๊ฑฐ ๊ฐ์ฒด๋ฅผ ๋๋ ค์ค์ ์ฑ๊ธํด๊ณผ ๋น์ทํ๊ฒ ๋์ํด. ๋ค๋ง ์ฑ๊ธํด์ ์ ์ญ ์ํ๋ผ์ ํ
์คํธ๋ฅผ ์ด๋ ต๊ฒ ๋ง๋๋ ๋ํ์ ์์ธ์ด๊ธฐ๋ ํด. ์์์ ๋ณธ DIP์ฒ๋ผ "ํ์ํ ๊ณณ์ ์ฃผ์
"ํ๋ ๋ฐฉ์์ ๋จผ์ ๊ณ ๋ คํ๋ ๊ฒ ์ข์.
ํฉํ ๋ฆฌ ๋ฉ์๋ & ์ถ์ ํฉํ ๋ฆฌ: ์์ฑ์ ์ ๋ฌธ๊ฐ์๊ฒ
"์ด๋ค ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ง"๋ฅผ ์ฌ์ฉํ๋ ์ชฝ์์ ๊ฒฐ์ ํ์ง ์๊ฒ ํ๋ ํจํด์ด์ผ. ํ์ด์ฌ์์ ํด๋์ค ์์ฒด๊ฐ ํธ์ถ ๊ฐ๋ฅํ ๊ฐ์ฒด๋ผ ๋์ ๋๋ฆฌ์ ๋ด์๋๊ธฐ๋ง ํด๋ ํฉํ ๋ฆฌ๊ฐ ๋ผ.
import json, csv, io
class JsonParser:
def parse(self, text): return json.loads(text)
class CsvParser:
def parse(self, text):
return list(csv.DictReader(io.StringIO(text)))
PARSERS = {"json": JsonParser, "csv": CsvParser}
def make_parser(fmt: str):
try:
return PARSERS[fmt]() # ํด๋์ค = ํฉํ ๋ฆฌ
except KeyError:
raise ValueError(f"์ง์ํ์ง ์๋ ํ์: {fmt}")
print(make_parser("json").parse('{"a": 1}'))
ํด๋์ค ์์์ ๋์ ์์ฑ์๋ฅผ ์ ๊ณตํ๋ @classmethod ํฉํ ๋ฆฌ๋ ์์ฒญ ์์ฃผ ์ฐ์ฌ. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ dict.fromkeys(), datetime.fromtimestamp(), int.from_bytes()๊ฐ ์ ๋ถ ์ด ํํ์ผ.
from datetime import date
class Member:
def __init__(self, name, birth: date):
self.name, self.birth = name, birth
@classmethod
def from_string(cls, raw: str):
name, ymd = raw.split(",")
return cls(name.strip(), date.fromisoformat(ymd.strip()))
m = Member.from_string("์์ฐ, 1998-04-12")
cls๋ฅผ ์ฐ๊ธฐ ๋๋ฌธ์ ํ์ ํด๋์ค์์ ํธ์ถํ๋ฉด ํ์ ํด๋์ค ๊ฐ์ฒด๊ฐ ๋ง๋ค์ด์ง๋ค๋ ๊ฒ๋ ์ฅ์ ์ด์ผ. ์ถ์ ํฉํ ๋ฆฌ๋ ์ฌ๊ธฐ์ ํ ๊ฑธ์ ๋ ๋๊ฐ์ "์๋ก ๊ด๋ จ๋ ๊ฐ์ฒด ๋ฌถ์"์ ํต์งธ๋ก ๋ง๋๋ ํจํด์ด์ผ. ์๋ฅผ ๋ค์ด ๋คํฌ ํ
๋ง ํฉํ ๋ฆฌ๋ ๋คํฌ ๋ฒํผ๊ณผ ๋คํฌ ์ฒดํฌ๋ฐ์ค๋ฅผ, ๋ผ์ดํธ ํ
๋ง ํฉํ ๋ฆฌ๋ ๋ผ์ดํธ ๋ฒ์ ์ ์ผ๊ด๋๊ฒ ๋ง๋ค์ด์ฃผ๋ ์์ด์ง.
๋น๋(Builder): ๋งค๊ฐ๋ณ์ ์ง์ฅ ํ์ถ
์๋ฐ์์๋ ์ธ์๊ฐ ์ด ๊ฐ์ฏค ๋๋ ์์ฑ์๋ฅผ ํผํ๋ ค๊ณ ๋น๋๋ฅผ ๋ง์ด ์ฐ๋๋ฐ, ํ์ด์ฌ์ ํค์๋ ์ธ์์ ๊ธฐ๋ณธ๊ฐ์ด ์์ด์ ๋๋ถ๋ถ ํ์ ์์ด. ํ์ด์ฌ 3.7๋ถํฐ ๋ค์ด์จ dataclasses๋ฅผ ์ฐ๋ฉด ๋ ๊น๋ํ์ง.
from dataclasses import dataclass, field
@dataclass(frozen=True)
class HttpRequest:
url: str
method: str = "GET"
headers: dict = field(default_factory=dict)
timeout: float = 10.0
retries: int = 0
req = HttpRequest("https://api.example.com", method="POST", retries=3)
๊ทธ๋๋ ๋น๋๊ฐ ๋น๋๋ ์๊ฐ์ด ์์ด. ๋จ๊ณ์ ์ผ๋ก ์กฐ๋ฆฝํด์ผ ํ๊ณ , ๋จ๊ณ๋ง๋ค ๊ฒ์ฆ์ด ํ์ํ๊ฑฐ๋, ์กฐ๋ฆฝ ์์๊ฐ ์๋ฏธ ์์ ๋์ผ. SQL ์ฟผ๋ฆฌ ๋น๋๊ฐ ๋ํ์ ์ด๊ณ , SQLAlchemy์ select(...).where(...).order_by(...) ๊ฐ์ ๋ฉ์๋ ์ฒด์ด๋ API๊ฐ ๊ทธ๋ฐ ๋ฐฉ์์ด์ผ.
class QueryBuilder:
def __init__(self, table):
self._table, self._wheres, self._limit = table, [], None
def where(self, cond):
self._wheres.append(cond); return self
def limit(self, n):
if n <= 0: raise ValueError("limit์ ์์")
self._limit = n; return self
def build(self):
sql = f"SELECT * FROM {self._table}"
if self._wheres:
sql += " WHERE " + " AND ".join(self._wheres)
if self._limit:
sql += f" LIMIT {self._limit}"
return sql
print(QueryBuilder("users").where("age > 20").limit(10).build())
# SELECT * FROM users WHERE age > 20 LIMIT 10
ํ๋กํ ํ์ (Prototype): ๋ณต์ฌํด์ ์ฐ์ด๋ด๊ธฐ
์์ฑ ๋น์ฉ์ด ํฐ ๊ฐ์ฒด๋ฅผ ์๋ณธ์ผ๋ก ๋๊ณ ๋ณต์ ํด์ ์ฐ๋ ํจํด์ด์ผ. ํ์ด์ฌ์ copy ๋ชจ๋์ด ์ด๋ฏธ ์ด๊ฑธ ํด์ค.
import copy
base_monster = {"name": "์ฌ๋ผ์", "hp": 30, "skills": ["๋ชธํต๋ฐ์น๊ธฐ"]}
shallow = copy.copy(base_monster)
deep = copy.deepcopy(base_monster)
shallow["skills"].append("์ ํ")
print(base_monster["skills"]) # ['๋ชธํต๋ฐ์น๊ธฐ', '์ ํ'] โ ์๋ณธ๊น์ง ์ค์ผ!
print(deep["skills"]) # ['๋ชธํต๋ฐ์น๊ธฐ'] โ ๋
๋ฆฝ์
์์ ๋ณต์ฌ๋ ๋ฐ๊นฅ ๊ป๋ฐ๊ธฐ๋ง ์๋ก ๋ง๋ค๊ณ ์์ชฝ ๋ฆฌ์คํธ๋ ๊ณต์ ํด. ์ค์ฒฉ๋ ๊ฐ๋ณ ๊ฐ์ฒด๊ฐ ์๋ค๋ฉด deepcopy๊ฐ ํ์ํ๊ณ , ํด๋์ค์์ ๋ณต์ฌ ๋์์ ์ง์ ์ ์ดํ๊ณ ์ถ์ผ๋ฉด __copy__, __deepcopy__ ๋งค์ง ๋ฉ์๋๋ฅผ ์ ์ํ๋ฉด ๋ผ.
๐ 5. ๊ตฌ์กฐ ํจํด: ๊ฐ์ฒด๋ค์ "์ด๋ป๊ฒ" ์ฎ์๊น
๊ตฌ์กฐ ํจํด์ ํด๋์ค์ ๊ฐ์ฒด๋ฅผ ์กฐํฉํด์ ๋ ํฐ ๊ตฌ์กฐ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ด์ผ. ํต์ฌ ํค์๋๋ ๊ฐ์ธ๊ธฐ(wrapping)์ ํฉ์ฑ(composition).
์ด๋ํฐ(Adapter): 220V๋ฅผ 110V๋ก
ํด์ธ์ฌํ ๊ฐ ๋ ์ฑ๊ธฐ๋ ๋ผ์ง์ฝ ์ด๋ํฐ ์๊ฐํ๋ฉด ๋ผ. ์ธํฐํ์ด์ค๊ฐ ์ ๋ง๋ ๋ ๊ฐ์ฒด๋ฅผ ์ฐ๊ฒฐํด์ฃผ๋ ํจํด์ด์ผ. ์ธ๋ถ ๊ฒฐ์ SDK๋ฅผ ์ฐ๋ํ ๋ ์ ๋ง ์์ฃผ ์จ.
class LegacyPayment: # ๋ฐ๊ฟ ์ ์๋ ์ธ๋ถ ์ฝ๋
def make_payment(self, amount_cents: int, currency_code: str):
return f"{amount_cents/100:.2f} {currency_code} ๊ฒฐ์ ์๋ฃ"
class PaymentGateway: # ์ฐ๋ฆฌ ์์คํ
์ ๊ธฐ๋ ์ธํฐํ์ด์ค
def pay(self, won: int) -> str: ...
class LegacyAdapter:
def __init__(self, legacy: LegacyPayment):
self._legacy = legacy
def pay(self, won: int) -> str:
return self._legacy.make_payment(won * 100, "KRW")
def checkout(gateway, amount):
print(gateway.pay(amount))
checkout(LegacyAdapter(LegacyPayment()), 15000)
# 15000.00 KRW ๊ฒฐ์ ์๋ฃ
๋ ํ์ดํ ๋๋ถ์ pay๋ง ์์ผ๋ฉด ๋๋, ํ์ด์ฌ์ ์ด๋ํฐ๋ ๋ค๋ฅธ ์ธ์ด๋ณด๋ค ํจ์ฌ ๊ฐ๋ณ๊ฒ ๋ง๋ค์ด์ ธ.
๋ฐ์ฝ๋ ์ดํฐ(Decorator): ์ด๋ฆ์ ๊ฐ์๋ฐ ๊ฒฐ์ด ์ด์ง ๋ฌ๋ผ
์ฌ๊ธฐ๊ฐ ํ์ด์ฌ ๊ฐ๋ฐ์๋ค์ด ์ ์ผ ๋ง์ด ํท๊ฐ๋ฆฌ๋ ์ง์ ์ด์ผ. GoF์ ๋ฐ์ฝ๋ ์ดํฐ ํจํด์ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ์ธํฐํ์ด์ค์ ๊ฐ์ฒด๋ก ๊ฐ์ธ์ ๋ฐํ์์ ๊ธฐ๋ฅ์ ๋ง๋ถ์ด๋ ๊ตฌ์กฐ ํจํด์ด๊ณ , ํ์ด์ฌ์ @decorator ๋ฌธ๋ฒ(PEP 318)์ ํจ์ยทํด๋์ค ์ ์๋ฅผ ๋ค๋ฅธ ํธ์ถ ๊ฐ๋ฅ ๊ฐ์ฒด๋ก ๊ฐ์ธ๋ ๋ฌธ๋ฒ์ ์ฅ์น์ผ. ์ด๋ฆ๊ณผ "๊ฐ์ธ์ ๊ธฐ๋ฅ ์ถ๊ฐ"๋ผ๋ ์ ์ ์ ๊ฐ์ง๋ง, ๊ฐ์ ๊ฐ๋
์ ์๋์ผ.
import functools, time
# ํ์ด์ฌ ๋ฐ์ฝ๋ ์ดํฐ ๋ฌธ๋ฒ โ ํจ์์ ๊ธฐ๋ฅ ๋ง๋ถ์ด๊ธฐ
def timer(func):
@functools.wraps(func) # ์๋ณธ ์ด๋ฆยทdocstring ๋ณด์กด
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
print(f"{func.__name__}: {time.perf_counter()-start:.4f}์ด")
return result
return wrapper
@timer
def heavy(n):
return sum(i*i for i in range(n))
heavy(1_000_000)
# GoF ๋ฐ์ฝ๋ ์ดํฐ ํจํด โ ๊ฐ์ฒด๋ฅผ ๊ฐ์ ์ธํฐํ์ด์ค๋ก ๊ฐ์ธ๊ธฐ
class Notifier:
def send(self, msg): print("์ด๋ฉ์ผ:", msg)
class SlackDecorator:
def __init__(self, wrapped): self._wrapped = wrapped
def send(self, msg):
self._wrapped.send(msg)
print("์ฌ๋:", msg)
class SmsDecorator:
def __init__(self, wrapped): self._wrapped = wrapped
def send(self, msg):
self._wrapped.send(msg)
print("๋ฌธ์:", msg)
SmsDecorator(SlackDecorator(Notifier())).send("์๋ฒ ๋ค์ด!")
GoF ๋ฒ์ ์ ์ฅ์ ์ ์กฐํฉ์ ํญ๋ฐ์ ๋ง๋ ๊ฒ์ด์ผ. ์ด๋ฉ์ผ+์ฌ๋, ์ด๋ฉ์ผ+๋ฌธ์, ์ด๋ฉ์ผ+์ฌ๋+๋ฌธ์โฆ ์ด๊ฑธ ์ ๋ถ ํ์ ํด๋์ค๋ก ๋ง๋ค๋ฉด ํด๋์ค๊ฐ ๊ธฐํ๊ธ์์ ์ผ๋ก ๋์ด๋๋๋ฐ, ๋ฐ์ฝ๋ ์ดํฐ๋ก ๊ฐ์ธ๋ฉด ๋ฐํ์์ ์ํ๋ ๋๋ก ์์ ์ ์์ด. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ functools.lru_cache, @property, @staticmethod๋ ์ ๋ถ ๋ฐ์ฝ๋ ์ดํฐ ๋ฌธ๋ฒ์ ๋ํ ์ฌ๋ก์ผ.
ํผ์ฌ๋(Facade): ๋ณต์กํ ๊ฑด ๋ค๋ก, ๋ฒํผ ํ๋๋ง ์์ผ๋ก
ํธํ ์ปจ์์ด์ง ๊ฐ์ ๊ฑฐ์ผ. ์๋น ์์ฝ, ํ์ ํธ์ถ, ๊ณต์ฐ ํฐ์ผ์ ๊ฐ๊ฐ ํ์ง ์๊ณ ์ปจ์์ด์ง ํ ๋ช ํํ ๋งํ๋ฉด ๋๋์์. ๋ณต์กํ ํ์ ์์คํ ์์ ๋จ์ํ ์ฐฝ๊ตฌ๋ฅผ ํ๋ ์ธ์ฐ๋ ํจํด์ด์ผ.
class VideoDecoder:
def decode(self, f): return f"๋์ฝ๋ฉ({f})"
class AudioMixer:
def mix(self, f): return f"์ค๋์ค({f})"
class SubtitleLoader:
def load(self, f): return f"์๋ง({f})"
class MediaPlayer: # ํผ์ฌ๋
def __init__(self):
self._v, self._a, self._s = VideoDecoder(), AudioMixer(), SubtitleLoader()
def play(self, file):
return " + ".join([self._v.decode(file), self._a.mix(file), self._s.load(file)])
print(MediaPlayer().play("movie.mp4"))
ํ์ด์ฌ์์ ์ฐ๋ฆฌ๊ฐ ๋งค์ผ ์ฐ๋ requests.get()์ด ์ข์ ์์์ผ. ๋ด๋ถ์์ ์ธ์
, ์ปค๋ฅ์
ํ, ์ด๋ํฐ, ์ธ์ฝ๋ฉ ์ฒ๋ฆฌ๊ฐ ๋ณต์กํ๊ฒ ์ฝํ ์์ง๋ง, ์ฌ์ฉ์์๊ฒ ํจ์ ํ๋๋ก ๋ณด์ด์ง. ํจํค์ง์ __init__.py์์ ํต์ฌ ๊ธฐ๋ฅ๋ง ๊ณจ๋ผ ๋
ธ์ถํ๋ ๊ฒ๋ ์ผ์ข
์ ํผ์ฌ๋๋ผ๊ณ ๋ณผ ์ ์์ด.
ํ๋ก์(Proxy): ๋๋ฆฌ์ธ์ ์ธ์ ์ ๊ทผ์ ํต์
์ง์ง ๊ฐ์ฒด ์์ ๊ฐ์ ์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ง ๋๋ฆฌ ๊ฐ์ฒด๋ฅผ ๋๊ณ , ์ง์ฐ ๋ก๋ฉยท์ ๊ทผ ์ ์ดยท์บ์ฑยท๋ก๊น
๊ฐ์ ๊ฑธ ์ฒ๋ฆฌํ๋ ํจํด์ด์ผ. ํ์ด์ฌ์ __getattr__์ ์ฐ๋ฉด ์ผ์ผ์ด ๋ฉ์๋๋ฅผ ๋ค์ ์ ์ํ์ง ์๊ณ ๋ ์์ํ ์ ์์ด.
class HugeModel:
def __init__(self):
print("โณ 2GB ๋ชจ๋ธ ๋ก๋ฉ ์ค...")
def predict(self, x): return x * 2
def info(self): return "๋ํ ๋ชจ๋ธ v1"
class LazyProxy:
def __init__(self, factory):
self._factory, self._obj = factory, None
def __getattr__(self, name): # ์๋ ์์ฑ ์ ๊ทผ ์์๋ง ํธ์ถ
if self._obj is None:
self._obj = self._factory()
return getattr(self._obj, name)
model = LazyProxy(HugeModel) # ์์ง ๋ก๋ฉ ์ ํจ
print("์ฑ ์์ ์๋ฃ")
print(model.predict(21)) # ์ด ์๊ฐ ๋ก๋ฉ โ 42
Django ORM์ QuerySet์ด ์ค์ ๋ก ๋ฐ์ดํฐ๊ฐ ํ์ํด์ง ๋๊น์ง ์ฟผ๋ฆฌ๋ฅผ ์คํํ์ง ์๋ ์ง์ฐ ํ๊ฐ(lazy evaluation)๋ ๊ฐ์ ์ฒ ํ์ด์ผ.
์ปดํฌ์งํธ(Composite): ํ๋๋ ๋ฌถ์์ด๋ ๋๊ฐ์ด
ํ์ผ๊ณผ ํด๋๋ฅผ ๋ ์ฌ๋ ค ๋ด. ํด๋ ์์ ํ์ผ๋ ์๊ณ ํด๋๋ ์์ง. ๊ทธ๋ฐ๋ฐ "์ฉ๋ ๊ณ์ฐ"์ ๋ ๋ค ๋๊ฐ์ด ๋ฌผ์ด๋ณผ ์ ์์ด์ผ ํด. ๊ฐ๋ณ ๊ฐ์ฒด์ ๊ฐ์ฒด ๋ฌถ์์ ๊ฐ์ ์ธํฐํ์ด์ค๋ก ๋ค๋ฃจ๋ ํธ๋ฆฌ ๊ตฌ์กฐ๊ฐ ์ปดํฌ์งํธ์ผ.
class File:
def __init__(self, name, size): self.name, self.size_ = name, size
def size(self): return self.size_
class Folder:
def __init__(self, name):
self.name, self.children = name, []
def add(self, node):
self.children.append(node); return self
def size(self):
return sum(child.size() for child in self.children)
root = Folder("ํ๋ก์ ํธ").add(File("main.py", 12)).add(
Folder("assets").add(File("logo.png", 340)).add(File("bg.jpg", 820))
)
print(root.size()) # 1172
HTML์ DOM ํธ๋ฆฌ, GUI ์์ ฏ ๊ณ์ธต, ํ์ด์ฌ ast ๋ชจ๋์ด ๋ง๋๋ ๊ตฌ๋ฌธ ํธ๋ฆฌ ๋ชจ๋ ์ปดํฌ์งํธ ๊ตฌ์กฐ์ผ.
ํ๋ผ์ด์จ์ดํธ(Flyweight)๋ ๊ณต์ ๊ฐ๋ฅํ ์ํ๋ฅผ ํ๋๋ง ๋ง๋ค์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋ผ๋ ํจํด์ด์ผ. ํ์ด์ฌ CPython ๊ตฌํ์ด ์์ ์ ์(-5~256)๋ฅผ ๋ฏธ๋ฆฌ ๋ง๋ค์ด ์ฌ์ฌ์ฉํ๊ณ ์ผ๋ถ ๋ฌธ์์ด์ ์ธํฐ๋ํ๋ ๊ฒ์ด ๋น์ทํ ์์ด๋์ด์ธ๋ฐ, ์ด๊ฑด ๊ตฌํ ์ธ๋ถ์ฌํญ์ด๋ผ ์ฝ๋๊ฐ ์ฌ๊ธฐ์ ์์กดํ๋ฉด ์ ๋ผ(๊ฐ ๋น๊ต๋ ํญ์
==๋ก!).
๐ญ 6. ํ์ ํจํด: ๊ฐ์ฒด๋ค์ด "์ด๋ป๊ฒ" ํ๋ ฅํ ๊น
ํ์ ํจํด์ ์ฑ ์์ ์ด๋ป๊ฒ ๋๋๊ณ ๊ฐ์ฒด๋ผ๋ฆฌ ์ด๋ป๊ฒ ๋ํํ ์ง๋ฅผ ๋ค๋ค. ๊ฐ์๊ฐ 11๊ฐ๋ก ๊ฐ์ฅ ๋ง๊ณ , ๋ ธ๋น ์ด ๋งํ "๋์ ์ธ์ด์์ ์ฌ๋ผ์ง๋ ํจํด"์ด ํนํ ๋ง์ด ๋ชฐ๋ ค ์๋ ์์ญ์ด๊ธฐ๋ ํด.
์ ๋ต(Strategy): ํด๋์ค ๋์ ํจ์๋ฅผ ๋๊ฒจ๋ผ
์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ ๋ผ์ธ ์ ์๊ฒ ๋ง๋๋ ํจํด์ด์ผ. ์๋ฐ๋ผ๋ฉด Strategy ์ธํฐํ์ด์ค์ ๊ตฌํ ํด๋์ค ์ฌ๋ฌ ๊ฐ๊ฐ ํ์ํ์ง๋ง, ํ์ด์ฌ์์๋ ํจ์๊ฐ ์ผ๊ธ ๊ฐ์ฒด๋ผ ๊ทธ๋ฅ ํจ์๋ฅผ ๋๊ธฐ๋ฉด ๋์ด์ผ.
class ShippingStrategy:
def cost(self, w): ...
class Express(ShippingStrategy):
def cost(self, w): return 5000 + w*100
class Standard(ShippingStrategy):
def cost(self, w): return 3000 + w*50
class Order:
def __init__(self, w, strategy):
self.w, self.s = w, strategy
def total(self):
return self.s.cost(self.w)
Order(3, Express()).total()def express(w): return 5000 + w*100
def standard(w): return 3000 + w*50
class Order:
def __init__(self, w, shipping):
self.w, self.shipping = w, shipping
def total(self):
return self.shipping(self.w)
Order(3, express).total()
Order(3, lambda w: 0).total() # ๋ฌด๋ฃ๋ฐฐ์ก ์ด๋ฒคํธ์ฐ๋ฆฌ๊ฐ ์ด๋ฏธ ๋งค์ผ ์ฐ๋ ์ ๋ต ํจํด๋ ์์ด. sorted(data, key=len)์ key ์ธ์๊ฐ ๋ฐ๋ก "์ ๋ ฌ ๊ธฐ์ค์ด๋ผ๋ ์ ๋ต"์ ํจ์๋ก ์ฃผ์
ํ๋ ๊ฑฐ์ผ. ๋ค๋ง ์ ๋ต์ด ์ฌ๋ฌ ๋ฉ์๋๋ ๋ด๋ถ ์ํ๋ฅผ ๊ฐ์ ธ์ผ ํ๋ค๋ฉด ํด๋์ค(๋๋ Protocol) ๋ฐฉ์์ด ๋ ์ ํฉํด.
์ต์๋ฒ(Observer): ๊ตฌ๋ ๊ณผ ์๋ฆผ
์ ํ๋ธ ๊ตฌ๋ ๋ฒํผ ๋๋ฅด๋ฉด ์ ์์ ์๋ฆผ ์ค์์? ํ ๊ฐ์ฒด(์ฃผ์ฒด)์ ์ํ๊ฐ ๋ฐ๋ ๋ ์์กดํ๋ ์ฌ๋ฌ ๊ฐ์ฒด(๊ด์ฐฐ์)์๊ฒ ์๋์ผ๋ก ์๋ ค์ฃผ๋ ํจํด์ด์ผ. ์ด๋ฒคํธ ์์คํ , GUI, ๋ฆฌ์กํฐ๋ธ ํ๋ก๊ทธ๋๋ฐ์ ๋ฟ๋ฆฌ์ง.
from collections import defaultdict
from typing import Callable
class EventBus:
def __init__(self):
self._subs: dict[str, list[Callable]] = defaultdict(list)
def subscribe(self, event: str, handler: Callable):
self._subs[event].append(handler)
def unsubscribe(self, event: str, handler: Callable):
self._subs[event].remove(handler)
def publish(self, event: str, **data):
for handler in list(self._subs[event]):
handler(**data)
bus = EventBus()
bus.subscribe("order_paid", lambda order_id, **_: print(f"๐ง {order_id} ์์์ฆ ๋ฐ์ก"))
bus.subscribe("order_paid", lambda order_id, **_: print(f"๐ฆ {order_id} ์ฌ๊ณ ์ฐจ๊ฐ"))
bus.subscribe("order_paid", lambda amount, **_: print(f"๐ ๋งค์ถ +{amount}"))
bus.publish("order_paid", order_id="A-1024", amount=39000)
์ฃผ๋ฌธ ์ฒ๋ฆฌ ์ฝ๋๋ ๋๊ฐ ๋ฃ๊ณ ์๋์ง ๋ชฐ๋ผ๋ ๋ผ. ๋์ค์ "ํฌ์ธํธ ์ ๋ฆฝ" ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ ค๋ฉด ๊ตฌ๋
์ ํ๋๋ง ๋ฑ๋กํ๋ฉด ๋. ์์์ ๋ณธ OCP๊ฐ ์์ฐ์ค๋ฝ๊ฒ ์ง์ผ์ง์ง? Django์ ์๊ทธ๋(post_save ๋ฑ)์ด ์ด ํจํด์ ์ค์ ๋ฒ์ ์ด์ผ.
weakref.WeakMethodยทweakref.WeakSet ๊ฐ์ ์ฝํ ์ฐธ์กฐ๋ฅผ ๊ณ ๋ คํด๋ด.
์ปค๋งจ๋(Command): ์์ฒญ์ ๊ฐ์ฒด๋ก ํฌ์ฅํ๊ธฐ
"์คํํ ์์ "์ ๊ฐ์ฒด๋ก ๋ง๋ค์ด์ ์ ์ฅยท์ ๋ฌยท์ทจ์ํ ์ ์๊ฒ ํ๋ ํจํด์ด์ผ. ์คํ ์ทจ์(Undo), ์์ ํ, ๋งคํฌ๋ก ๋ นํ์ ๋ฑ์ด์ผ.
class TextEditor:
def __init__(self): self.text = ""
class InsertCommand:
def __init__(self, editor, s):
self.editor, self.s = editor, s
def execute(self):
self.editor.text += self.s
def undo(self):
self.editor.text = self.editor.text[:-len(self.s)]
class History:
def __init__(self): self._stack = []
def run(self, cmd):
cmd.execute(); self._stack.append(cmd)
def undo(self):
if self._stack: self._stack.pop().undo()
ed, h = TextEditor(), History()
h.run(InsertCommand(ed, "์๋
"))
h.run(InsertCommand(ed, ", ํ์ด์ฌ"))
print(ed.text) # ์๋
, ํ์ด์ฌ
h.undo()
print(ed.text) # ์๋
Undo๊ฐ ํ์ ์๊ณ "๋์ค์ ์คํ"๋ง ํ์ํ๋ค๋ฉด ํ์ด์ฌ์์ ํจ์ ๊ฐ์ฒด๋ functools.partial๋ก ์ถฉ๋ถํด. Celery ๊ฐ์ ์์
ํ์ ํ์คํฌ๋ฅผ ๋ฃ๋ ๊ฒ๋ ๋๊ฒ ๋ณด๋ฉด ์ปค๋งจ๋ ํจํด์ ์ฌ๊ณ ๋ฐฉ์์ด์ผ.
ํ ํ๋ฆฟ ๋ฉ์๋(Template Method): ๋ผ๋๋ ๋ถ๋ชจ๊ฐ, ์ด์ ์์์ด
์๊ณ ๋ฆฌ์ฆ์ ํฐ ํ๋ฆ์ ๋ถ๋ชจ ํด๋์ค์ ๊ณ ์ ํ๊ณ , ์ผ๋ถ ๋จ๊ณ๋ง ์์์ด ์ฑ์ฐ๊ฒ ํ๋ ํจํด์ด์ผ. ์์์ ์ ๋นํ๊ฒ ์ฐ๋ ๋ํ ์ฌ๋ก์ง.
from abc import ABC, abstractmethod
class DataPipeline(ABC):
def run(self): # ํ
ํ๋ฆฟ ๋ฉ์๋: ์์ ๊ณ ์
raw = self.extract()
clean = self.transform(raw)
self.load(clean)
self.on_finish()
@abstractmethod
def extract(self): ...
@abstractmethod
def transform(self, raw): ...
@abstractmethod
def load(self, data): ...
def on_finish(self): # ํ
(hook): ์ ํ์ ์ค๋ฒ๋ผ์ด๋
print("โ
ํ์ดํ๋ผ์ธ ์๋ฃ")
class CsvToDb(DataPipeline):
def extract(self): return [" a ", " b"]
def transform(self, raw): return [x.strip() for x in raw]
def load(self, data): print("DB ์ ์ฅ:", data)
CsvToDb().run()
unittest.TestCase๊ฐ ์ข์ ์ค์ ์์์ผ. ํ๋ ์์ํฌ๊ฐ setUp โ ํ
์คํธ ๋ฉ์๋ โ tearDown ํ๋ฆ์ ์ ํด๋๊ณ , ์ฐ๋ฆฌ๋ ๊ฐ ๋จ๊ณ๋ฅผ ์ฑ์ฐ๊ธฐ๋ง ํ์ง.
๋ฐ๋ณต์(Iterator): ํ์ด์ฌ์ ์ด๋ฏธ ์ธ์ด์ ๋ น์ ์์ด
์ปฌ๋ ์
๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ์จ๊ธด ์ฑ ์์๋ฅผ ํ๋์ฉ ๊บผ๋ด๋ ํจํด์ธ๋ฐ, ํ์ด์ฌ์์๋ for๋ฌธ ์์ฒด๊ฐ ์ด ํจํด ์์ ์ ์์ด. __iter__์ __next__๋ก ์ดํฐ๋ ์ดํฐ ํ๋กํ ์ฝ์ ์ง์ ๊ตฌํํ ์๋ ์์ง๋ง, ์ ๋๋ ์ดํฐ๋ฅผ ์ฐ๋ฉด ๋ช ์ค๋ก ๋๋.
class Playlist:
def __init__(self, songs): self._songs = songs
def __iter__(self): # ์ ๋๋ ์ดํฐ๋ก ๋ฐ๋ณต์ ํจํด ์์ฑ
for song in self._songs:
if not song.startswith("#"): # ์จ๊น ๊ณก ๊ฑด๋๋ฐ๊ธฐ
yield song
for s in Playlist(["๋ด๋ ", "#๋น๊ณต๊ฐ๊ณก", "๋ฐคํธ์ง"]):
print("๐ต", s)
def read_large_log(path): # ๋์ฉ๋ ํ์ผ๋ ๋ฉ๋ชจ๋ฆฌ ๊ฑฑ์ ์์ด
with open(path, encoding="utf-8") as f:
for line in f:
if "ERROR" in line:
yield line.rstrip()
์ด ์ง์ ์ด ๋
ธ๋น
์ ์ฃผ์ฅ์ด ๊ฐ์ฅ ์ค๊ฐ ๋๋ ๊ณณ์ด์ผ. GoF์์ ๋ณ๋ ํด๋์ค ์ค๊ณ๊ฐ ํ์ํ๋ ํจํด์ด ํ์ด์ฌ์์ yield ํค์๋ ํ๋๋ก ์ธ์ด์ ๋
น์ ์๋ ๊ฑฐ์ง.
์ํ(State): if๋ฌธ ์ง์ฅ ๋์ ์ํ ๊ฐ์ฒด
๊ฐ์ฒด์ ์ํ์ ๋ฐ๋ผ ํ๋์ด ์์ ํ ๋ฌ๋ผ์ง ๋, ์ํ๋ง๋ค ํด๋์ค๋ฅผ ๋๊ณ ํ๋์ ์์ํ๋ ํจํด์ด์ผ. ์ฃผ๋ฌธ(๋๊ธฐ โ ๊ฒฐ์ โ ๋ฐฐ์ก โ ์๋ฃ), ์ํ๊ธฐ, ๊ฒ์ ์บ๋ฆญํฐ ๊ฐ์ ์ ํ ์ํ ๊ธฐ๊ณ์ ์ ๋ง์.
class Pending:
def next(self, order): order.state = Paid()
def cancel(self, order): order.state = Cancelled()
def __str__(self): return "๊ฒฐ์ ๋๊ธฐ"
class Paid:
def next(self, order): order.state = Shipped()
def cancel(self, order): order.state = Cancelled(); print("๐ธ ํ๋ถ ์ฒ๋ฆฌ")
def __str__(self): return "๊ฒฐ์ ์๋ฃ"
class Shipped:
def next(self, order): print("์ด๋ฏธ ๋ฐฐ์ก ์ค์ด์์")
def cancel(self, order): print("๋ฐฐ์ก ํ์ ๋ฐํ ์ ์ฒญ์ ํด์ฃผ์ธ์")
def __str__(self): return "๋ฐฐ์ก ์ค"
class Cancelled:
def next(self, order): print("์ทจ์๋ ์ฃผ๋ฌธ์ด์์")
def cancel(self, order): print("์ด๋ฏธ ์ทจ์๋จ")
def __str__(self): return "์ทจ์"
class Order:
def __init__(self): self.state = Pending()
def next(self): self.state.next(self)
def cancel(self): self.state.cancel(self)
o = Order(); o.next(); print(o.state) # ๊ฒฐ์ ์๋ฃ
o.cancel(); print(o.state) # ๐ธ ํ๋ถ ์ฒ๋ฆฌ โ ์ทจ์
์ํ๊ฐ ์๋ก ์๊ฒจ๋ ํด๋์ค ํ๋๋ง ์ถ๊ฐํ๋ฉด ๋๊ณ , "๋ฐฐ์ก ์ค์ผ ๋ ์ทจ์ํ๋ฉด?" ๊ฐ์ ๊ท์น์ด ํด๋น ์ํ ํด๋์ค ์์ ๋ชจ์ฌ ์์ด ์ฐพ๊ธฐ ์ฌ์. ์ํ๊ฐ ๋์ธ ๊ฐ๋ฟ์ด๊ณ ๊ท์น์ด ๋จ์ํ๋ฉด enum.Enum๊ณผ ๋์
๋๋ฆฌ ์ ์ดํ๋ก๋ ์ถฉ๋ถํ๋ ๊ท๋ชจ์ ๋ง์ถฐ ๊ณ ๋ฅด๋ฉด ๋ผ.
functools.singledispatch๋ก ํ์
๋ณ ํจ์๋ฅผ ๋ฑ๋กํ๋ ๋ฐฉ์์ด ๊ฐ๊ฒฐํ ๋์์ด ๋๊ณ , 3.10๋ถํฐ ๋์
๋ match๋ฌธ(๊ตฌ์กฐ์ ํจํด ๋งค์นญ, PEP 634)๋ ๋น์ทํ ๋ฌธ์ ๋ฅผ ๋ค๋ฅธ ๊ฐ๋์์ ํ์ด์ค. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ast.NodeVisitor๊ฐ ๋ฐฉ๋ฌธ์ ํจํด์ ๊ต๊ณผ์์ ๊ตฌํ์ด์ผ.์ฑ ์ ์ฐ์(Chain of Responsibility): ์์ฒญ์ ์ฒ๋ฆฌํ ์ ์๋ ํธ๋ค๋ฌ๋ฅผ ์ฌ์ฌ์ฒ๋ผ ์ด์ด. ์น ํ๋ ์์ํฌ์ ๋ฏธ๋ค์จ์ด ์ฒด์ธ์ด ๋ํ์ ์ด์ผ.
๋ฉ๋ฉํ ยท์ค์ฌ์ยท์ธํฐํ๋ฆฌํฐ๋ ์๋๋ฐ, ๊ฐ๊ฐ ์ํ ์ค๋ ์ ์ ์ฅ, ๊ฐ์ฒด ๊ฐ ํต์ ์ ์ค์ ์ง์ค, ์์ ์ธ์ด์ ๋ฌธ๋ฒ ํด์์ ๋ค๋ค.
โ๏ธ 7. ์์ vs ํฉ์ฑ: ํ์ด์ฌ์์ ๊ฐ์ฅ ์ค์ํ ์ ํ
์์์ ๋ณธ ํจํด๋ค์ ์ญ ๋์๋ณด๋ฉด, ๋๋ถ๋ถ ์์๋ณด๋ค "๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ํ๊ณ ์ผ์ ๋งก๊ธฐ๋ ํฉ์ฑ"์ ์ฐ๊ณ ์์ด. GoF์ ๋ ๋ฒ์งธ ๋์์น์ด ๊ดํ ๋์จ ๊ฒ ์๋์ผ.
| ๋น๊ต ํญ๋ชฉ | ์์ (is-a) | ํฉ์ฑ (has-a) |
|---|---|---|
| ๊ฒฐํฉ๋ | ๋ถ๋ชจ ๋ด๋ถ ๊ตฌํ์ ๊ฐํ๊ฒ ๋ฌถ์ | ์ธํฐํ์ด์ค๋ก๋ง ์ฐ๊ฒฐ๋์ด ๋์จํจ |
| ๋ณ๊ฒฝ ์์ | ํด๋์ค ์ ์ ์์ ์ ๊ณ ์ | ๋ฐํ์์ ๋ถํ ๊ต์ฒด ๊ฐ๋ฅ |
| ํ ์คํธ | ๋ถ๋ชจ๊น์ง ํจ๊ป ์ค๋นํด์ผ ํจ | ๊ฐ์ง ๋ถํ(mock) ์ฃผ์ ์ด ์ฌ์ |
| ์ด์ธ๋ฆฌ๋ ์ํฉ | ์ง์ง ํ์์ is-a, ํ ํ๋ฆฟ ๋ฉ์๋, ํ๋ ์์ํฌ ํ์ฅ์ | ๊ธฐ๋ฅ ์กฐ๋ฆฝ, ์ ๋ต ๊ต์ฒด, ๋๋ถ๋ถ์ ๋น์ฆ๋์ค ๋ก์ง |
์์์ด ๋ฌด์กฐ๊ฑด ๋์๋ค๋ ์๊ธฐ๋ ์๋์ผ. ๋ถ๋ชจ ํด๋์ค์ ์ฝ๋๊ฐ ๋ฐ๋๋ฉด ์์์ด ์๋์น ์๊ฒ ๊นจ์ง ์ ์๋ค๋ "๊นจ์ง๊ธฐ ์ฌ์ด ๊ธฐ๋ฐ ํด๋์ค(fragile base class)" ๋ฌธ์ ๋ฅผ ์๊ณ ์ฐ์๋ ๊ฑฐ์ง. ์ค๋ฌด ๊ฐ๊ฐ์ผ๋ก๋ ์ด๋ฐ ์ง๋ฌธ์ ๋์ ธ๋ณด๋ฉด ์ข์.
๐ ๏ธ 8. ์ค์ ๋ฆฌํฉํฐ๋ง: ์คํ๊ฒํฐ ์ฝ๋๋ฅผ ํจํด์ผ๋ก ์ด๋ ค๋ด๊ธฐ
์ด๋ก ์ ์ถฉ๋ถํ ๋ดค์ผ๋, ์ง์ง ์์ ๋ฒํ ์ฝ๋๋ฅผ ๋จ๊ณ์ ์ผ๋ก ๊ณ ์ณ๋ณด์. ์๋๋ฆฌ์ค๋ "์ฃผ๋ฌธ ์๋ฃ ํ ์๋ฆผ ๋ณด๋ด๊ธฐ"์ผ.
Before: ๋ชจ๋ ๊ฑธ ๋ค ํ๋ ํจ์
def complete_order(order, channel):
order["status"] = "done"
if channel == "email":
import smtplib
# ... SMTP ์ฐ๊ฒฐ, ๋ฉ์ผ ๋ฐ์ก ...
print("์ด๋ฉ์ผ ๋ฐ์ก")
elif channel == "sms":
# ... ๋ฌธ์ API ํธ์ถ ...
print("๋ฌธ์ ๋ฐ์ก")
elif channel == "kakao":
print("์นด์นด์ค ์๋ฆผํก ๋ฐ์ก")
with open("log.txt", "a") as f:
f.write(f"{order['id']} done\n")
๋ฌธ์ ์ ์ด ํ๋์ ๋ณด์ด์ง? ์ํ ๋ณ๊ฒฝยท์๋ฆผยท๋ก๊น ์ด ํ ํจ์์ ๋ชฐ๋ ค ์๊ณ (SRP ์๋ฐ), ์ฑ๋ ์ถ๊ฐํ ๋๋ง๋ค if๋ฌธ์ ๊ณ ์ณ์ผ ํ๊ณ (OCP ์๋ฐ), ์ค์ SMTP์ ์ง์ ์์กดํด์ ํ ์คํธ๊ฐ ๋ถ๊ฐ๋ฅํด(DIP ์๋ฐ).
After: ์์น๊ณผ ํจํด์ ์ ์ฉ
from typing import Protocol
from dataclasses import dataclass
class Notifier(Protocol): # ์ถ์ (ISPยทDIP)
def notify(self, order_id: str) -> None: ...
NOTIFIERS: dict[str, type] = {} # ํฉํ ๋ฆฌ ๋ ์ง์คํธ๋ฆฌ (OCP)
def channel(name):
def deco(cls):
NOTIFIERS[name] = cls
return cls
return deco
@channel("email")
class EmailNotifier:
def notify(self, order_id): print(f"๐ง {order_id} ์ด๋ฉ์ผ")
@channel("sms")
class SmsNotifier:
def notify(self, order_id): print(f"๐ฑ {order_id} ๋ฌธ์")
class OrderLogger: # ๋ก๊น
์ฑ
์ ๋ถ๋ฆฌ (SRP)
def log(self, order_id): print(f"๐ {order_id} done")
@dataclass
class OrderService: # ์์กด์ฑ ์ฃผ์
(DIP)
notifier: Notifier
logger: OrderLogger
def complete(self, order: dict):
order["status"] = "done"
self.notifier.notify(order["id"])
self.logger.log(order["id"])
svc = OrderService(NOTIFIERS["email"](), OrderLogger())
svc.complete({"id": "A-77"})
# ํ
์คํธ์์ ๊ฐ์ง ์๋ฆผ๊ธฐ ์ฃผ์
class FakeNotifier:
def __init__(self): self.sent = []
def notify(self, order_id): self.sent.append(order_id)
fake = FakeNotifier()
OrderService(fake, OrderLogger()).complete({"id": "T-1"})
assert fake.sent == ["T-1"]
์นด์นด์ค ์๋ฆผํก์ด ์ถ๊ฐ๋๋ฉด? @channel("kakao") ํด๋์ค ํ๋ ์ถ๊ฐํ๋ฉด ๋์ด์ผ. ๊ธฐ์กด ์ฝ๋๋ ํ ์ค๋ ์ ๊ฑด๋๋ ค. ์ฌ๋ฌ ์ฑ๋์ ๋์์ ๋ณด๋ด๊ณ ์ถ์ผ๋ฉด ์๋ฆผ๊ธฐ ๋ฆฌ์คํธ๋ฅผ ํ์ ์ปดํฌ์งํธ๋ฅผ ํ๋ ๋ง๋ค์ด ์ฃผ์
ํ๋ฉด ๋๊ณ . ์ด๋ ๊ฒ ํจํด์ ๋ฐ๋ก๋ฐ๋ก๊ฐ ์๋๋ผ ์กฐํฉํด์ ์ธ ๋ ์ง์ง ํ์ด ๋์.
โก ๊ฐ์ฅ ์์ฃผ ๋ฐ๋๋ ๋ถ๋ถ(์ฌ๊ธฐ์ ์๋ฆผ ์ฑ๋)์ ์ฐพ์ ์ถ์์ผ๋ก ๋ถ๋ฆฌํด.
โข ํ ๋ฒ์ ํ๋์ฉ ์๊ฒ ๋ฐ๊พธ๊ณ ๋งค๋ฒ ํ ์คํธ๋ฅผ ๋๋ ค.
ํผ์ ํ๋จ์ด ์ด๋ ค์ด ๋ ๊ฑฐ์ ์ฝ๋๋ผ๋ฉด ์ฌ๋ฅ๋ท ๊ฐ์ ์ฌ๋ฅ ๊ณต์ ํ๋ซํผ์์ ๊ฒฝํ ๋ง์ ํ์ด์ฌ ๊ฐ๋ฐ์์๊ฒ ์ฝ๋ ๋ฆฌ๋ทฐ๋ฅผ ๋ฐ์๋ณด๋ ๊ฒ๋ ์ํ์ฐฉ์ค๋ฅผ ํ ์ค์ด๋ ๋ฐฉ๋ฒ์ด์ผ.
๐จ 9. ํจํด ๊ณผ์ฉ์ด๋ผ๋ ํจ์ : ์ํฐํจํด ์ฒดํฌ๋ฆฌ์คํธ
ํจํด์ ๋ง ๋ฐฐ์ด ์๊ธฐ์ ๊ฐ์ฅ ํํ ๊ฑธ๋ฆฌ๋ ๋ณ์ด ์์ด. ์ด๋ฆํ์ฌ "๋ง์น๋ฅผ ๋ ์ฌ๋์๊ฒ ๋ชจ๋ ๊ฒ ๋ชป์ผ๋ก ๋ณด์ธ๋ค" ์ฆํ๊ตฐ. ํ์ด์ฌ์ ์ฒ ํ์ด ๋ด๊ธด PEP 20 ใThe Zen of Pythonใ์๋ ์ด๋ฐ ๊ตฌ์ ์ด ์์ง.
Simple is better than complex.
Flat is better than nested.
If the implementation is hard to explain, it's a bad idea.
โ PEP 20, The Zen of Python (Tim Peters)
ํ์ด์ฌ ์ธํฐํ๋ฆฌํฐ์์ import this๋ฅผ ์น๋ฉด ์ ๋ฌธ์ ๋ณผ ์ ์์ด. ํจํด์ ๋ฃ๊ธฐ ์ ์ ์ด ๊ตฌ์ ๋ค์ ํ ๋ฒ์ฉ ๋ ์ฌ๋ ค ๋ด.
get_name()/set_name()์ ํ์ด์ฌ์์ ๋ถํ์ํด. ๊ทธ๋ฅ ๊ณต๊ฐ ์์ฑ์ผ๋ก ๋๊ณ , ๋์ค์ ๊ฒ์ฆ์ด ํ์ํด์ง๋ฉด @property๋ก ๋ฐ๊พธ๋ฉด ํธ์ถ ์ฝ๋๋ ๊ทธ๋๋ก์ผ.__init__๊ณผ ๋ฉ์๋ ํ๋๋ฟ์ธ ํด๋์ค๋ ๋๊ฐ ํจ์(๋๋ ํด๋ก์ , functools.partial)๋ก ๋ฐ๊ฟ ์ ์์ด.๐บ๏ธ 10. ํ๋์ ๋ณด๋ ํ์ด์ฌ ํจํด ์ ํ ๊ฐ์ด๋
๋ง์ง๋ง์ผ๋ก, ์ํฉ๋ณ๋ก "๊ต๊ณผ์ ํจํด"๊ณผ "ํ์ด์ฌ์์ ๋จผ์ ๋ ์ฌ๋ฆด ๋์"์ ์ ๋ฆฌํด ๋ณผ๊ฒ. ๋์์ผ๋ก ํด๊ฒฐ๋๋ค๋ฉด ๊ทธ๊ฒ ๋ณดํต ๋ ํ์ด์ฌ๋ค์ด ์ ํ์ด์ผ.
| ์ด๋ฐ ๊ณ ๋ฏผ์ด ์์ ๋ | GoF ํจํด | ํ์ด์ฌ์์ ๋จผ์ ๋ ์ฌ๋ฆด ๊ฒ |
|---|---|---|
| ์ ์ญ์ ํ๋๋ง ํ์ํด | ์ฑ๊ธํด | ๋ชจ๋ ์์ค ๊ฐ์ฒด, ์์กด์ฑ ์ฃผ์ |
| ์ ๋ ฅ์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ์ฒด ์์ฑ | ํฉํ ๋ฆฌ ๋ฉ์๋ | ํด๋์ค ๋์
๋๋ฆฌ, @classmethod |
| ์ธ์๊ฐ ๋๋ฌด ๋ง์ | ๋น๋ | ํค์๋ ์ธ์, @dataclass |
| ๊ฐ์ฒด ๋ณต์ | ํ๋กํ ํ์ | copy.copy / copy.deepcopy |
| ๊ธฐ๋ฅ์ ๋ง์์ฐ๊ณ ์ถ์ด | ๋ฐ์ฝ๋ ์ดํฐ | ๋ฐ์ฝ๋ ์ดํฐ ๋ฌธ๋ฒ, functools.wraps |
| ์ ๊ทผ์ ์ง์ฐยทํต์ | ํ๋ก์ | __getattr__ ์์, functools.cached_property |
| ์๊ณ ๋ฆฌ์ฆ ๊ต์ฒด | ์ ๋ต | ํจ์ ์ ๋ฌ, key= ์ธ์ |
| ์ํ ๋ฐฉ์ ์จ๊ธฐ๊ธฐ | ๋ฐ๋ณต์ | ์ ๋๋ ์ดํฐ, yield |
| ์ด๋ฒคํธ ์๋ฆผ | ์ต์๋ฒ | ์ฝ๋ฐฑ ๋ฆฌ์คํธ, ํ๋ ์์ํฌ ์๊ทธ๋ |
| ํ์ ๋ณ๋ก ๋ค๋ฅธ ์ฐ์ฐ | ๋ฐฉ๋ฌธ์ | functools.singledispatch, match๋ฌธ |
โก SOLID๋ ํจํด์ด ์ข์์ง ํ๋จํ๋ ๊ธฐ์ค์ด๊ณ , ๋ค์ฏ ์์น ๋ชจ๋ "๋ณ๊ฒฝ ๋น์ฉ ์ต์ํ"๋ฅผ ํฅํด.
โข ํ์ด์ฌ์ ์ผ๊ธ ํจ์ยท๋ ํ์ดํยท๋ชจ๋ยท์ ๋๋ ์ดํฐ ๋๋ถ์ ๋ง์ ํจํด์ด ํจ์ฌ ๋จ์ํ ํํ๋ก ๊ตฌํ๋ผ.
โฃ ์์๋ณด๋ค ํฉ์ฑ, ๊ตฌํ๋ณด๋ค ์ธํฐํ์ด์ค(Protocol)๋ฅผ ๋จผ์ ๊ณ ๋ คํด.
โค ํจํด์ ๋ฌธ์ ๊ฐ ๋ณด์ผ ๋ ๊บผ๋ด๋ ๊ณต๊ตฌ์ผ. ๋ฌธ์ ๊ฐ ์๋๋ฐ ๊บผ๋ด๋ฉด ๊ทธ๊ฒ ๋ฐ๋ก ์ํฐํจํด!
์ฌ๊ธฐ๊น์ง ๋ฐ๋ผ์๋ค๋ฉด ์ด์ ์ฝ๋๋ฅผ ๋ณผ ๋ "์, ์ด๊ฑด ์ ๋ต์ด๋ค", "์ด๊ฑด SRP ์๋ฐ์ด๋ค" ํ๋ ๋์ด ์๊ฒผ์ ๊ฑฐ์ผ. ๋ค์์ ์ฝ๋๋ฅผ ์ง๋ค๊ฐ if๋ฌธ์ด ์ธ ๊ฐ์งธ ๋์ด๋๋ ์๊ฐ, ์ค๋ ๋ณธ ๋ ์ง์คํธ๋ฆฌ์ ์ ๋ต ํจํด์ ๋ ์ฌ๋ ค ๋ด. ๊ทธ ์์ ์ ํ ํ๋๊ฐ 6๊ฐ์ ๋ค์ ๋๋ฅผ ๊ตฌํด์ค ํ ๋๊น. ๐โจ
๐ ์ฐธ๊ณ ์๋ฃ
Erich Gamma ์ธ, ใDesign Patterns: Elements of Reusable Object-Oriented Softwareใ, Addison-Wesley, 1994
Peter Norvig, ใDesign Patterns in Dynamic Languagesใ โ https://norvig.com/design-patterns/
PEP 20 โ The Zen of Python โ https://peps.python.org/pep-0020/
PEP 544 โ Protocols: Structural subtyping โ https://peps.python.org/pep-0544/
PEP 318 โ Decorators for Functions and Methods โ https://peps.python.org/pep-0318/
PEP 634 โ Structural Pattern Matching โ https://peps.python.org/pep-0634/
The Python 2.3 Method Resolution Order โ https://docs.python.org/3/howto/mro.html
Python ๊ณต์ ๋ฌธ์ abc / dataclasses / functools / copy ๋ชจ๋ โ https://docs.python.org/3/library/
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.