전략 패턴(Strategy Pattern)
전략 패턴(Strategy Pattern)은 객체지향 디자인 패턴 중 하나로, 알고리즘을 실행 중에 선택하거나 교체할 수 있도록 해주는 패턴이다. 이 패턴은 알고리즘의 사용을 캡슐화하고, 이를 사용하는 클라이언트와 독립적으로 알고리즘을 변경할 수 있게 해준다. 전략 패턴은 특히 알고리즘을 사용하는 클라이언트와 알고리즘 자체를 분리하고 싶을 때 유용하다.
전략 패턴의 구성 요소
- Context (컨텍스트): 전략을 사용하는 역할을 한다. 필요한 전략을 설정하고, 전략을 이용해 연산을 수행한다.
- Strategy (전략): 모든 전략의 공통 인터페이스이다. 이 인터페이스를 구현함으로써 구체적인 알고리즘(전략)들이 정의된다.
- ConcreteStrategy (구체적인 전략): Strategy 인터페이스를 실제로 구현한 클래스들이다. 각각 다른 방법으로 문제를 해결하는 알고리즘을 포함한다.
전략 패턴의 예
예를 들어, 다양한 종류의 정렬 알고리즘을 선택할 수 있는 프로그램을 생각해 볼 수 있다. 사용자는 런타임에 원하는 정렬 전략을 선택할 수 있다. 정렬 알고리즘(퀵 정렬, 병합 정렬, 버블 정렬 등) 각각을 ConcreteStrategy로 구현하고, 이를 Context에서 사용할 수 있도록 한다.
from abc import ABC, abstractmethod
from typing import List
# Strategy 인터페이스
class SortStrategy(ABC):
@abstractmethod
def sort(self, dataset: List[int]) -> List[int]:
pass
# ConcreteStrategy 1: 퀵 정렬
class QuickSort(SortStrategy):
def sort(self, dataset: List[int]) -> List[int]:
if len(dataset) <= 1:
return dataset
pivot = dataset[len(dataset) // 2]
left = [x for x in dataset if x < pivot]
middle = [x for x in dataset if x == pivot]
right = [x for x in dataset if x > pivot]
return self.sort(left) + middle + self.sort(right)
# ConcreteStrategy 2: 버블 정렬
class BubbleSort(SortStrategy):
def sort(self, dataset: List[int]) -> List[int]:
n = len(dataset)
for i in range(n):
for j in range(0, n-i-1):
if dataset[j] > dataset[j+1]:
dataset[j], dataset[j+1] = dataset[j+1], dataset[j]
return dataset
# Context
class Sorter:
def __init__(self, strategy: SortStrategy):
self.strategy = strategy
def set_strategy(self, strategy: SortStrategy):
self.strategy = strategy
def sort(self, dataset: List[int]) -> List[int]:
return self.strategy.sort(dataset)
# 클라이언트 코드
dataset = [3, 5, 2, 9, 1]
sorter = Sorter(QuickSort())
print("Quick Sort:", sorter.sort(dataset))
sorter.set_strategy(BubbleSort())
print("Bubble Sort:", sorter.sort(dataset))
전략 패턴의 장점
- 확장성: 새로운 전략을 추가하려면 Strategy 인터페이스를 구현하는 새 클래스를 만들면 된다.
- 교체 용이성: 런타임에 전략을 쉽게 변경할 수 있다.
- 분리와 캡슐화: 알고리즘과 클라이언트 코드의 분리를 통해 유지보수와 확장성이 용이해진다.
전략 패턴을 사용하면 프로그램의 유연성이 증가하고, 변경에 더 강해지며, 다양한 알고리즘을 쉽게 교체할 수 있게 된다.
함수지향 전략(Functional Programming Strategy)
함수지향 전략(Functional Programming Strategy)은 객체지향 프로그래밍의 전략 패턴을 함수의 형태로 구현하는 접근 방식을 말한다. 이는 주로 함수를 일급 객체로 다루는 함수형 프로그래밍 언어에서 볼 수 있는 패턴이다. 파이썬과 같이 함수를 일급 객체로 취급하는 언어에서는 이 패턴을 매우 간결하게 구현할 수 있다.
함수지향 전략의 핵심 개념
- 일급 객체로서의 함수: 함수를 변수에 할당하거나, 다른 함수의 인자로 전달하거나, 함수에서 결과로 반환할 수 있다.
- 고차 함수(Higher-order functions): 함수를 인자로 받거나 함수를 결과로 반환하는 함수이다.
- 람다 함수(Lambda functions): 이름 없이 선언된 짧은 함수로, 간단한 기능을 인라인으로 표현하는 데 유용하다.
예시: 정렬 전략을 함수로 구현
앞서 설명한 전략 패턴의 예제를 함수지향 접근법으로 다시 구현해볼 수 있다. 이 때, 정렬 알고리즘은 별도의 클래스를 정의하는 대신, 단순히 함수로 정의한다.
from typing import List, Callable
# 정렬 전략을 함수로 정의
def quick_sort(dataset: List[int]) -> List[int]:
if len(dataset) <= 1:
return dataset
pivot = dataset[len(dataset) // 2]
left = [x for x in dataset if x < pivot]
middle = [x for x in dataset if x == pivot]
right = [x for x in dataset if x > pivot]
return quick_sort(left) + middle + quick_sort(right)
def bubble_sort(dataset: List[int]) -> List[int]:
n = len(dataset)
for i in range(n):
for j in range(0, n-i-1):
if dataset[j] > dataset[j+1]:
dataset[j], dataset[j+1] = dataset[j+1], dataset[j]
return dataset
# 정렬 함수를 인자로 받는 고차 함수
def sort_dataset(dataset: List[int], strategy: Callable[[List[int]], List[int]]) -> List[int]:
return strategy(dataset)
# 클라이언트 코드
dataset = [3, 5, 2, 9, 1]
sorted_data = sort_dataset(dataset, quick_sort)
print("Quick Sort:", sorted_data)
sorted_data = sort_dataset(dataset, bubble_sort)
print("Bubble Sort:", sorted_data)
함수지향 전략의 장점
- 간결성: 함수만 정의하면 되므로, 클래스를 사용한 객체지향 방식보다 코드가 더 간결해진다.
- 유연성: 전략을 함수로 쉽게 교체할 수 있으며, 함수를 동적으로 변경하거나 확장하는 것이 쉽다.
- 재사용성: 독립적인 함수는 다른 컨텍스트에서도 재사용하기 쉽다.
함수지향 전략은 특히 함수형 프로그래밍 언어의 특징을 활용하여, 코드의 유연성과 재사용성을 극대화할 수 있는 방법을 제공한다. 이는 또한 복잡한 객체지향 디자인 패턴을 단순화하고, 개발자가 코드의 의도를 더 명확하게 전달할 수 있도록 돕는다.
플라이웨이트(Flyweight) 패턴
플라이웨이트(Flyweight) 패턴은 객체지향 디자인 패턴 중 하나로, 많은 수의 유사 객체들을 효율적으로 공유하여 메모리 사용량을 줄이는 데 사용된다. 이 패턴은 주로 성능 최적화 목적으로 사용되며, 대규모 객체 네트워크에서 작은 메모리 절감이 전체 성능에 큰 영향을 미칠 수 있는 경우에 특히 유용하다.
플라이웨이트 패턴의 구성 요소
- Flyweight (플라이웨이트): 공유될 수 있는 객체의 공통 상태를 정의한다. 이 상태는 내부 상태(Intrinsic state)라고 하며, 객체간에 독립적이지 않고 공유된다.
- Concrete Flyweight (구체적 플라이웨이트): Flyweight 인터페이스를 구현하는 클래스로, 공유 가능한 실제 객체이다.
- Flyweight Factory (플라이웨이트 팩토리): Flyweight 객체를 생성하고 관리하며, 클라이언트 요청에 따라 이미 생성된 인스턴스를 재사용하거나 새로운 인스턴스를 생성한다.
- Client (클라이언트): Flyweight 객체를 사용한다. 외부 상태(Extrinsic state)를 관리하며, 이는 Flyweight 객체가 독립적으로 사용할 수 없는 상태 정보를 제공한다.
플라이웨이트 패턴의 예시
예를 들어, 텍스트 편집기를 생각해보겠다. 각 글자(Character)는 독특한 스타일 정보(폰트 유형, 크기, 굵기 등)를 가질 수 있다. 글자의 스타일 정보가 많은 문서에서 중복될 수 있는 경우, 플라이웨이트 패턴을 사용하여 스타일 속성을 공유함으로써 메모리 사용을 최적화할 수 있다.
class CharacterStyle:
def __init__(self, font, size, bold):
self.font = font
self.size = size
self.bold = bold
class CharacterStyleFactory:
_styles = {}
@classmethod
def get_style(cls, font, size, bold):
# 스타일 식별을 위한 키 생성
key = (font, size, bold)
if key not in cls._styles:
cls._styles[key] = CharacterStyle(font, size, bold)
return cls._styles[key]
class Character:
def __init__(self, char, font, size, bold):
self.char = char
self.style = CharacterStyleFactory.get_style(font, size, bold)
# 클라이언트 코드
char_a = Character('A', 'Arial', 12, False)
char_b = Character('A', 'Arial', 12, False)
print(char_a.style == char_b.style) # True, 같은 스타일 객체를 공유
플라이웨이트 패턴의 장점
- 메모리 절감: 대량의 객체가 비슷한 데이터를 공유함으로써 메모리 사용을 크게 줄일 수 있다.
- 성능 향상: 객체 생성 비용이 감소하고, 더 적은 메모리 사용으로 인해 캐시 효율성이 높아질 수 있다.
플라이웨이트 패턴은 주로 게임 개발, GUI 라이브러리의 구현, 문서 편집기 등 다양한 곳에서 볼 수 있다. 객체의 수가 많고, 그 객체들이 상태를 공유할 수 있는 경우에 특히 유용하게 사용된다.
전략패턴에 문제점을 해결하는 수단: 모듈에서 전략 찾기
전략 패턴(Strategy Pattern)을 사용하면서 발생할 수 있는 문제 중 하나는 많은 수의 전략이 생성되고 관리되어야 하는 복잡성이다. 이를 해결하는 한 가지 방법은 모듈에서 전략을 동적으로 찾고 로드하는 것이다. 이 접근법은 특히 전략이 많고 다양하며, 실행 시간에 동적으로 전략을 선택해야 하는 경우에 유용하다.
모듈에서 전략 찾기: 동적 로딩 접근법
모듈에서 전략을 찾아 로드하는 접근법은 Python의 리플렉션(reflection) 기능과 모듈 핸들링 기능을 활용한다. 이를 통해 코드는 더 유연해지며, 새로운 전략을 추가할 때 기존 코드를 수정할 필요 없이 확장할 수 있다.
주요 개념
- 리플렉션: 프로그램이 실행 중에 자신의 구조를 검사하고 수정할 수 있는 프로세스이다. Python에서는 types 모듈, getattr, hasattr 같은 함수를 사용하여 객체의 속성과 메서드를 동적으로 접근할 수 있다.
- 모듈 동적 로드: importlib 모듈을 사용하여 프로그램 실행 중에 새로운 모듈을 로드할 수 있다. 이를 통해 전략 객체를 포함하는 모듈을 동적으로 로드하고 해당 전략을 사용할 수 있다.
구현 방법
- 전략 인터페이스 정의: 모든 전략이 공통으로 구현할 메서드를 정의한다.
- 전략 모듈 작성: 각 전략을 별도의 모듈로 작성하고, 모듈 내에서 전략 클래스를 구현한다.
- 전략 팩토리 구현: 전략을 동적으로 로드하고 인스턴스화하는 팩토리 클래스를 구현한다.
- 클라이언트 코드: 클라이언트는 팩토리를 통해 필요한 전략을 요청하고 사용한다.
예제 코드
import importlib
from strategies.ConcreteStrategyA import ConcreteStrategyA
from strategies.ConcreteStrategyB import ConcreteStrategyB
from strategies.strategy_interface import StrategyInterface
class StrategyFactory:
@staticmethod
def get_strategy(strategy_name):
try:
module = importlib.import_module(f"strategies.{strategy_name}")
strategy_class = getattr(module, strategy_name)
return strategy_class()
except (ImportError, AttributeError) as e:
print(f"Error loading strategy {strategy_name}: {e}")
return None
# 클라이언트 코드
strategy = StrategyFactory.get_strategy("ConcreteStrategyA")
if strategy:
strategy.execute()
# strategies/ConcreteStrategyA.py
from .strategy_interface import StrategyInterface
class ConcreteStrategyA(StrategyInterface):
def execute(self):
print("Executing ConcreteStrategyA")
# strategies/ConcreteStrategyB.py
from .strategy_interface import StrategyInterface
class ConcreteStrategyB(StrategyInterface):
def execute(self):
print("Executing ConcreteStrategyB")
# strategies.strategy_interface.py
class StrategyInterface:
def execute(self):
pass장점
- 확장성: 새로운 전략을 추가하려면 해당 모듈만 생성하면 된다.
- 유연성: 실행 시간에 전략을 변경하거나 업데이트할 수 있다.
- 분리 및 캡슐화: 전략 로직이 별도의 모듈로 분리되어 있어, 각 전략의 독립성이 보장된다.
단점
- 초기 설정 복잡성: 모듈을 동적으로 로드하는 시스템을 설계하고 구현하는 것이 복잡할 수 있다.
- 오류 처리: 모듈이나 클래스가 존재하지 않을 때의 오류 처리가 필요하다.
모듈에서 전략을 찾는 접근법은 소프트웨어의 유지보수와 확장을 용이하게 하며, 다양한 전략을 효율적으로 관리할 수 있는 강력한 방법을 제공한다.
globals()를 활용한 전략 패턴
globals() 함수는 파이썬에서 매우 유용하게 사용되는 내장 함수로, 현재의 전역 심볼 테이블을 딕셔너리 형태로 반환한다. 이 전역 심볼 테이블은 현재 모듈에 정의된 모든 전역 변수와 함수, 클래스 등을 포함하고 있다. 이를 통해 프로그램은 실행 중에 전역 변수의 값을 조회하거나 변경할 수 있다.
globals() 사용 예
x = 10
y = 20
def print_globals():
global_vars = globals()
print(global_vars)
print_globals()
이 예제에서 print_globals() 함수는 현재 모듈의 전역 변수 x와 y를 포함하는 전역 심볼 테이블을 출력한다.
globals() 주요 특징
- 반환 값: globals()는 딕셔너리를 반환한다. 이 딕셔너리는 수정 가능하므로, 전역 변수의 값을 동적으로 변경할 수 있다.
- 활용 방안: 전역 변수를 관리하거나, 함수나 클래스와 같은 식별자를 동적으로 참조할 때 유용하다. 또한 디버깅 시에 전역 환경을 확인하는 데 도움을 줄 수 있다.
globals() 사용 시 주의할 점
- 보안 리스크: 전역 심볼 테이블을 수정할 수 있으므로, 신중하게 사용해야 한다. 민감한 정보를 전역 변수에 저장하는 경우, 의도치 않게 정보가 노출될 수 있다.
- 코드의 명확성: 전역 변수를 빈번히 수정하거나 동적으로 접근하는 코드는 유지보수가 어렵고 오류를 유발할 수 있다. 코드의 명확성과 안정성을 위해 지역 변수를 사용하거나 클래스와 객체를 통해 상태를 관리하는 방법을 고려하는 것이 좋다.
globals()는 파이썬에서 매우 강력한 기능을 제공하지만, 이를 적절히 사용하는 것이 중요하다. 전역 상태의 남용은 프로그램의 복잡성을 증가시키고 버그의 원인이 될 수 있으므로, 항상 주의를 기울여야 한다.
globals()를 활용한 전략 패턴 예제
다음은 globals()를 사용하여 전략 패턴을 구현하는 간단한 예제이다:
class StrategyInterface:
def execute(self):
raise NotImplementedError("Execute method not implemented.")
class ConcreteStrategyA(StrategyInterface):
def execute(self):
print("Executing strategy A")
class ConcreteStrategyB(StrategyInterface):
def execute(self):
print("Executing strategy B")
class StrategyContext:
def __init__(self, strategy_name):
strategy_class = globals().get(strategy_name)
if strategy_class:
self.strategy = strategy_class()
else:
raise ValueError(f"Strategy {strategy_name} not found")
def execute_strategy(self):
self.strategy.execute()
# 클라이언트 코드
if __name__ == "__main__":
strategy_context = StrategyContext('ConcreteStrategyA')
strategy_context.execute_strategy()
strategy_context = StrategyContext('ConcreteStrategyB')
strategy_context.execute_strategy()
코드 설명
- StrategyInterface: 모든 전략이 구현해야 할 인터페이스를 정의한다.
- ConcreteStrategyA 및 B: StrategyInterface를 구현하는 구체적인 전략 클래스들이다.
- StrategyContext: 전략을 설정하고 실행하는 컨텍스트 클래스이다. 생성자에서 전략 이름을 받아 globals()를 통해 해당 전략 클래스를 찾고 인스턴스화한다.
- 클라이언트 코드: StrategyContext 객체를 생성하고, 각기 다른 전략을 실행시킨다.
장점
- 간결성: importlib을 사용하는 대신 현재 모듈 내에서 직접 클래스를 찾아 활용할 수 있어 코드가 간결해진다.
- 간편한 구현: 복잡한 모듈 로딩이나 외부 파일 관리 없이 전략을 쉽게 교체할 수 있다.
단점
- 유연성 제한: globals()는 현재 모듈에 정의된 심볼만 찾을 수 있으므로, 다른 모듈의 클래스를 로드하려면 추가적인 접근 방법이 필요하다.
- 보안과 안정성: 전역 네임스페이스를 사용하기 때문에, 프로그램의 안정성이나 보안에 영향을 줄 수 있는 요소가 포함될 수 있다.
globals() 함수를 사용하는 방식은 특히 작은 규모의 프로젝트나 단일 모듈로 구성된 애플리케이션에서 전략을 동적으로 관리할 때 유용한다. 하지만 프로젝트의 규모가 커지거나 복잡성이 증가할 때는 더 체계적인 접근 방법이 필요할 수 있다.
inspect를 활용한 전략 패턴
파이썬의 inspect 모듈을 사용하면 실행 중인 프로그램의 객체에 대한 깊은 정보를 얻을 수 있다. 이 모듈은 라이브 객체, 소스 코드의 메타데이터, 소스 코드 자체에 대한 정보 등을 검사할 수 있게 도와준다. 이를 통해 클래스나 함수, 메서드, 코루틴 등의 상세 정보를 동적으로 알아내고 관리할 수 있다.
inspect 모듈의 주요 기능
- 클래스와 함수의 정보 얻기: 객체가 함수인지, 클래스인지, 메서드인지 등을 확인하고, 관련 정보를 가져올 수 있다.
- 소스 코드 접근: 함수나 클래스의 소스 코드를 문자열로 가져올 수 있다.
- 스택 프레임 분석: 호출 스택을 검사하여 현재 실행 중인 함수와 그 맥락을 파악할 수 있다.
- 실행 가능 객체의 파라미터 정보: 함수의 시그니처(인자 목록, 반환 타입 등)를 분석할 수 있다.
inspect를 활용한 전략 패턴 예제
다음은 inspect 모듈을 활용하여 모듈 내의 특정 기준에 맞는 클래스를 찾아 전략 패턴에서 사용하는 예제이다.
import inspect
import sys
class StrategyInterface:
def execute(self):
raise NotImplementedError("Execute method must be implemented by the subclass.")
class ConcreteStrategyA(StrategyInterface):
def execute(self):
print("Executing Concrete Strategy A")
class ConcreteStrategyB(StrategyInterface):
def execute(self):
print("Executing Concrete Strategy B")
def is_strategy(cls):
return inspect.isclass(cls) and issubclass(cls, StrategyInterface) and cls is not StrategyInterface
def find_strategies():
strategies = []
# inspect.getmembers 함수를 이용하여 현재 모듈의 멤버들을 검사
for name, obj in inspect.getmembers(sys.modules[__name__], is_strategy):
strategies.append(obj)
return strategies
# 클라이언트 코드
strategies = find_strategies()
for strategy_class in strategies:
strategy = strategy_class()
strategy.execute()
코드 설명
- StrategyInterface: 모든 전략 클래스가 상속받아야 하는 인터페이스이다.
- ConcreteStrategyA 및 ConcreteStrategyB: 구체적인 전략을 구현하는 클래스이다.
- is_strategy: 전달된 클래스가 StrategyInterface의 서브클래스인지 판단하는 함수이다.
- find_strategies: 현재 모듈에서 StrategyInterface의 서브클래스를 모두 찾아 리스트로 반환하는 함수이다.
장점
- 동적 탐색: 실행 중인 모듈 내의 클래스를 동적으로 탐색하고 인스턴스화 할 수 있다.
- 유연성: 새로운 전략을 추가하기 위해 코드를 변경할 필요가 없으며, 유지 보수가 편리하다.
단점
- 성능 문제: 리플렉션 및 동적 탐색은 성능에 영향을 줄 수 있으므로 필요할 때만 사용하는 것이 좋다.
- 복잡성 증가: 코드의 복잡성이 증가할 수 있으며, 디버깅이 어려워질 수 있다.
inspect 모듈은 코드의 내부 구조를 탐색하고 이해하는 데 큰 도움을 줄 수 있으며, 다양한 고급 기능을 제공한다. 이를 통해 보다 동적이고 유연한 코드를 작성할 수 있다.
명령 패턴(Command Pattern)
명령 패턴(Command Pattern)은 객체지향 디자인 패턴 중 하나로, 요청을 객체의 형태로 캡슐화하여 사용자가 요청을 발행하는 코드와 요청을 수행하는 코드를 분리할 수 있도록 한다. 이 패턴은 요청을 클래스로 표현함으로써 매개변수화, 큐에 저장, 로그 기록, 취소 가능 등의 작업을 지원하게 만든다.
명령 패턴의 주요 구성 요소
- Command (명령): 실행될 모든 명령에 대한 인터페이스이다. 일반적으로 execute() 메서드를 가지며, 이 메서드는 명령을 수행하는 데 필요한 작업을 정의한다.
- ConcreteCommand (구체적 명령): Command 인터페이스를 구현하는 클래스로, 특정한 작업을 실행한다. 이 클래스는 Receiver 객체를 참조하고, execute 메서드를 호출할 때 Receiver에 정의된 메서드를 사용하여 요청을 수행한다.
- Receiver (수신자): 실제로 작업을 수행하는 객체이다. ConcreteCommand의 execute 메서드에 의해 호출되는 메서드를 구현한다.
- Invoker (호출자): Command 객체를 받아서 저장해두었다가 필요할 때 Command 객체의 execute() 메서드를 호출하여 명령을 실행한다. 종종 메뉴, 버튼 클릭 이벤트 등 사용자 인터페이스 요소와 관련된다.
- Client (클라이언트): ConcreteCommand 객체를 생성하고 그것의 Receiver를 설정한다. 또한 Invoker에게 명령을 전달할 수 있다.
명령 패턴의 예시
예를 들어, TV 리모컨을 프로그래밍할 때, 각 버튼이 실행할 명령(채널 변경, 볼륨 조절 등)을 객체로 캡슐화할 수 있다.
from abc import ABC, abstractmethod
class Command(ABC):
@abstractmethod
def execute(self):
pass
class Light:
def turn_on(self):
print("The light is on")
def turn_off(self):
print("The light is off")
class TurnOnCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_on()
class TurnOffCommand(Command):
def __init__(self, light):
self.light = light
def execute(self):
self.light.turn_off()
class RemoteControl:
def __init__(self):
self.command = None
def set_command(self, command):
self.command = command
def press_button(self):
if self.command:
self.command.execute()
# 클라이언트 코드
light = Light()
turn_on_command = TurnOnCommand(light)
remote = RemoteControl()
remote.set_command(turn_on_command)
remote.press_button()
turn_off_command = TurnOffCommand(light)
remote.set_command(turn_off_command)
remote.press_button()명령 패턴의 장점
- 유연성: 클라이언트는 명령을 수행하는 객체와는 독립적으로 명령을 제어할 수 있다.
- 확장성: 새로운 명령을 쉽게 추가할 수 있으며, 기존 코드를 변경하지 않고도 다양한 요청을 처리할 수 있다.
- 복합 명령: 복수의 명령을 조합하여 매크로 명령을 쉽게 구성할 수 있다.
- 작업 로그 및 취소: 실행된 명령의 기록을 유지하고, 이를 바탕으로 작업을 취소하거나 재실행할 수 있다.
명령 패턴은 사용자 인터페이스, 트랜잭션 시스템, 도구 상자 및 매크로 기능 등을 구현하는 데 유용하게 사용될 수 있다.
모든 코드는 github에 저장되어 있습니다.
'Python study' 카테고리의 다른 글
| 객체 참조, 가변성, 재활용 (0) | 2024.05.13 |
|---|---|
| 함수 데커레이터(Decorator) & 클로저(Closure) (0) | 2024.05.10 |
| 일급 함수 (0) | 2024.05.06 |
| 텍스트(text)와 바이트(byte) (0) | 2024.05.04 |
| 딕셔너리(dictionary)와 집합(set) (0) | 2024.04.29 |
