컨텍스트 매니저는 코드 블록을 진입하고 나올 때 자동으로 설정 및 정리 작업을 수행하는 데 사용된다. 일반적으로 with 문과 함께 사용되며, 자원 관리(파일, 네트워크 연결, 락 등)에 유용하다. 파이썬에서는 두 가지 방법으로 컨텍스트 매니저를 구현할 수 있다: __enter__ 및 __exit__ 메서드를 사용하거나, contextlib 모듈의 데코레이터를 사용하는 방법이 있다.

기본 사용법

컨텍스트 매니저는 with 문을 사용하여 구현된다. 다음은 파일을 열고 자동으로 닫는 예제이다.

with open('example.txt', 'w') as file:
    file.write('Hello, World!')

위 예제에서 with 문이 끝나면 파일이 자동으로 닫힌다.

__enter__ 및 __exit__ 메서드를 사용한 구현

컨텍스트 매니저를 직접 구현하려면, 클래스에 __enter__와 __exit__ 메서드를 정의해야 한다.

class MyContextManager:
    def __enter__(self):
        print("Entering the context")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting the context")

# 사용 예시
with MyContextManager():
    print("Inside the context")

위 예제에서 with 블록에 진입하면 __enter__ 메서드가 호출되고, 블록을 빠져나오면 __exit__ 메서드가 호출된다.

__enter__

__enter__ 메서드는 with 블록에 진입할 때 호출된다. 이 메서드는 선택적으로 값을 반환할 수 있으며, with 문 내에서 사용할 수 있다.

class Resource:
    def __enter__(self):
        print("Acquiring resource")
        return self

    def do_something(self):
        print("Using resource")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Releasing resource")

# 사용 예시
with Resource() as resource:
    resource.do_something()

__exit__

__exit__ 메서드는 with 블록을 벗어날 때 호출된다. 이 메서드는 네 개의 인자를 받으며, 각각 예외의 타입, 값, 트레이스백을 나타낸다. 예외가 발생하지 않으면 None이 전달된다.

class Resource:
    def __enter__(self):
        print("Acquiring resource")
        return self

    def do_something(self):
        print("Using resource")

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            print(f"Exception: {exc_val}")
        print("Releasing resource")

# 사용 예시
with Resource() as resource:
    resource.do_something()
    # 일부러 예외 발생
    raise ValueError("Something went wrong")

응용 예제

다음은 데이터베이스 연결을 관리하는 컨텍스트 매니저의 예제이다.

class DatabaseConnection:
    def __enter__(self):
        print("Connecting to the database")
        self.connection = self.connect()
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.connection.close()
        print("Closing the database connection")

    def connect(self):
        # 가상의 데이터베이스 연결
        class Connection:
            def close(self):
                print("Connection closed")

        return Connection()

# 사용 예시
with DatabaseConnection() as conn:
    print("Using the database connection")

contextlib 모듈을 사용한 구현

contextlib 모듈을 사용하면 더 간편하게 컨텍스트 매니저를 구현할 수 있다. contextlib.contextmanager 데코레이터를 사용하면 함수 기반의 컨텍스트 매니저를 만들 수 있다.

from contextlib import contextmanager

@contextmanager
def my_context_manager():
    print("Entering the context")
    yield
    print("Exiting the context")

# 사용 예시
with my_context_manager():
    print("Inside the context")

파이썬에서 프로토콜은 정식으로 클래스의 메서드나 속성을 정의하지 않고도 특정 동작을 따르는 객체를 만들기 위한 개념이다. 프로토콜을 사용하면 타입 힌팅과 정적 타입 검사를 더 효과적으로 할 수 있다. 이는 주로 typing 모듈의 Protocol 클래스를 사용하여 정의된다.

기본 사용법

다음은 Protocol을 사용하여 프로토콜을 정의하고 이를 구현하는 예제이다.

from typing import Protocol

class Flyer(Protocol):
    def fly(self) -> None:
        ...

class Bird:
    def fly(self) -> None:
        print("Bird is flying")

class Airplane:
    def fly(self) -> None:
        print("Airplane is flying")

# 사용 예시
def let_it_fly(flyer: Flyer) -> None:
    flyer.fly()

bird = Bird()
airplane = Airplane()

let_it_fly(bird)      # Bird is flying
let_it_fly(airplane)  # Airplane is flying

자세한 설명

Protocol 클래스

Protocol 클래스는 타입 힌팅과 정적 타입 검사를 위해 사용된다. Protocol을 상속받아 정의된 클래스는 인터페이스처럼 동작하며, 이를 구현하는 클래스는 프로토콜에 정의된 메서드와 속성을 제공해야 한다.

from typing import Protocol

class ExampleProtocol(Protocol):
    def method(self) -> None:
        ...

이 프로토콜을 구현하는 클래스는 method 메서드를 제공해야 한다.

정적 타입 검사

Protocol을 사용하면 타입 힌팅과 함께 정적 타입 검사를 통해 코드의 일관성을 유지할 수 있다. 이는 mypy와 같은 타입 검사기를 통해 이루어진다.

프로토콜과 상속

프로토콜은 명시적인 상속 없이도 특정 메서드나 속성을 제공하는 모든 클래스에 적용될 수 있다. 즉, 덕 타이핑(duck typing)을 이용한 형태로 동작한다.

class Swimmer(Protocol):
    def swim(self) -> None:
        ...

class Fish:
    def swim(self) -> None:
        print("Fish is swimming")

class Human:
    def swim(self) -> None:
        print("Human is swimming")

# 사용 예시
def let_it_swim(swimmer: Swimmer) -> None:
    swimmer.swim()

fish = Fish()
human = Human()

let_it_swim(fish)  # Fish is swimming
let_it_swim(human)  # Human is swimming

덕 타이핑은 파이썬과 같은 동적 타이핑 언어에서 사용되는 개념으로, 객체의 실제 타입보다 객체의 현재 메서드나 속성에 따라 행동을 결정하는 방식이다. 이는 "오리처럼 걷고 오리처럼 소리내면 그것은 오리일 것이다"라는 철학에 기초한다. 즉, 객체가 특정 인터페이스를 구현했는지 여부를 확인하지 않고, 필요한 메서드나 속성을 가지고 있으면 사용한다.

응용 예제

좀 더 복잡한 예제로, 프로토콜을 사용하여 다양한 형태의 데이터를 읽고 쓰는 인터페이스를 정의해보자.

from typing import Protocol

class DataReader(Protocol):
    def read(self) -> str:
        ...

class DataWriter(Protocol):
    def write(self, data: str) -> None:
        ...

class FileReader:
    def __init__(self, filename: str):
        self.filename = filename

    def read(self) -> str:
        with open(self.filename, 'r') as file:
            return file.read()

class FileWriter:
    def __init__(self, filename: str):
        self.filename = filename

    def write(self, data: str) -> None:
        with open(self.filename, 'w') as file:
            file.write(data)

# 사용 예시
def process_data(reader: DataReader, writer: DataWriter) -> None:
    data = reader.read()
    # 데이터 처리 로직 (예: 모든 텍스트를 대문자로 변환)
    processed_data = data.upper()
    writer.write(processed_data)

file_reader = FileReader('input.txt')
file_writer = FileWriter('output.txt')

process_data(file_reader, file_writer)

파이썬에서 추상 클래스는 주로 abc 모듈을 사용하여 정의한다. 추상 클래스는 하나 이상의 추상 메서드를 포함하는 클래스로, 직접 인스턴스화할 수 없다. 대신, 서브클래스에서 추상 메서드를 반드시 구현해야 한다. 이는 공통 인터페이스를 강제하고, 코드의 구조와 일관성을 유지하는 데 유용하다.

기본 사용법

추상 클래스를 정의하기 위해서는 abc.ABC를 상속하고, abc.abstractmethod 데코레이터를 사용하여 추상 메서드를 정의한다.

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

    @abstractmethod
    def move(self):
        pass

# 사용 예시
class Dog(Animal):
    def sound(self):
        return "Bark"

    def move(self):
        return "Runs"

class Bird(Animal):
    def sound(self):
        return "Chirp"

    def move(self):
        return "Flies"

# 인스턴스 생성
dog = Dog()
bird = Bird()

print(dog.sound())  # Bark
print(dog.move())   # Runs
print(bird.sound()) # Chirp
print(bird.move())  # Flies

# 추상 클래스는 직접 인스턴스화할 수 없다.
try:
    animal = Animal()
except TypeError as e:
    print(e)  # "Can't instantiate abstract class Animal with abstract methods move, sound"

자세한 설명

ABC 클래스

abc.ABC는 파이썬에서 추상 클래스를 정의할 때 사용하는 기본 클래스이다. 이를 상속받는 클래스는 추상 클래스가 된다.

from abc import ABC

class MyAbstractClass(ABC):
    pass

abstractmethod 데코레이터

abc.abstractmethod 데코레이터는 메서드를 추상 메서드로 정의하는 데 사용된다. 추상 메서드는 서브클래스에서 반드시 구현해야 하며, 구현하지 않을 경우 서브클래스도 추상 클래스가 된다.

from abc import ABC, abstractmethod

class MyAbstractClass(ABC):
    @abstractmethod
    def my_method(self):
        pass

추상 클래스와 상속

추상 클래스는 서브클래스에서 구현해야 할 공통 인터페이스를 정의하는 데 유용하다. 서브클래스가 추상 메서드를 모두 구현하면, 인스턴스를 생성할 수 있다.

class ConcreteClass(MyAbstractClass):
    def my_method(self):
        print("This is the implementation of the abstract method")

# 사용 예시
obj = ConcreteClass()
obj.my_method()  # This is the implementation of the abstract method

응용 예제

다음은 도형의 면적을 계산하는 추상 클래스를 정의하고, 이를 상속받는 서브클래스에서 면적을 계산하는 예제이다.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * (self.radius ** 2)

    def perimeter(self):
        return 2 * 3.14159 * self.radius

# 사용 예시
rectangle = Rectangle(5, 10)
circle = Circle(7)

print("Rectangle area:", rectangle.area())  # Rectangle area: 50
print("Rectangle perimeter:", rectangle.perimeter())  # Rectangle perimeter: 30
print("Circle area:", circle.area())  # Circle area: 153.93804
print("Circle perimeter:", circle.perimeter())  # Circle perimeter: 43.98226

파이썬에서 __slots__는 클래스 속성을 고정하여 메모리 사용을 최적화하고 성능을 향상시키는 데 사용된다. 기본적으로 파이썬 객체는 __dict__라는 딕셔너리를 사용하여 속성을 저장한다. 하지만 __slots__를 사용하면 이 딕셔너리를 생략하고, 고정된 속성만을 가진 객체를 만들 수 있다.

기본 사용법

다음은 __slots__의 기본적인 사용법이다.

class MyClass:
    __slots__ = ['attribute1', 'attribute2']

    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

# 사용 예시
obj = MyClass(10, 20)
print(obj.attribute1)  # 10
print(obj.attribute2)  # 20

# 새로운 속성을 추가하려고 하면 오류 발생
try:
    obj.attribute3 = 30
except AttributeError as e:
    print(e)  # 'MyClass' object has no attribute 'attribute3'

자세한 설명

__slots__의 장점

1. 메모리 사용 감소: __slots__를 사용하면 객체가 __dict__를 사용하지 않기 때문에 메모리 사용량이 줄어든다.

2. 성능 향상: 메모리 사용이 최적화되어 객체 생성 및 속성 접근 속도가 빨라진다.

__slots__의 제한사항

1. 고정된 속성: __slots__에 명시된 속성 외에 새로운 속성을 추가할 수 없다.

2. 상속의 제한: __slots__를 사용한 클래스를 상속할 때 자식 클래스도 __slots__를 명시적으로 정의해야 한다.

3. 호환성 문제: 일부 라이브러리나 기능과의 호환성에 문제가 있을 수 있다.

상속에서의 __slots__

__slots__를 사용한 클래스를 상속할 때 자식 클래스에서 __slots__를 추가로 정의할 수 있다. 이 경우, 부모 클래스의 __slots__를 자식 클래스에 포함시켜야 한다.

class Parent:
    __slots__ = ['attribute1']

    def __init__(self, attribute1):
        self.attribute1 = attribute1

class Child(Parent):
    __slots__ = ['attribute2']

    def __init__(self, attribute1, attribute2):
        super().__init__(attribute1)
        self.attribute2 = attribute2

# 사용 예시
child = Child(10, 20)
print(child.attribute1)  # 10
print(child.attribute2)  # 20

# 새로운 속성을 추가하려고 하면 오류 발생
try:
    child.attribute3 = 30
except AttributeError as e:
    print(e)  # 'Child' object has no attribute 'attribute3'

__slots__의 응용 예제

다음은 __slots__를 사용하여 메모리 사용을 최적화한 간단한 2D 점(Point) 클래스를 구현한 예제이다.

class Point:
    __slots__ = ['x', 'y']

    def __init__(self, x, y):
        self.x = x
        self.y = y

# 사용 예시
p1 = Point(1, 2)
p2 = Point(3, 4)

print(p1.x, p1.y)  # 1 2
print(p2.x, p2.y)  # 3 4

# 메모리 사용량 비교
import sys

class PointWithoutSlots:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p3 = PointWithoutSlots(1, 2)
print("With __slots__: ", sys.getsizeof(p1))  # __slots__ 사용 시
print("Without __slots__: ", sys.getsizeof(p3))  # __slots__ 미사용 시

이 예제에서는 __slots__를 사용하여 Point 클래스의 메모리 사용량을 최적화하였다. sys.getsizeof() 함수를 사용하여 __slots__를 사용한 경우와 사용하지 않은 경우의 메모리 사용량을 비교할 수 있다.

파이썬의 property는 객체 지향 프로그래밍에서 매우 유용하게 사용되는 기능이다. property는 클래스의 속성(attribute)에 접근할 때, 단순한 접근을 넘어 추가적인 처리를 가능하게 해준다. 즉, 속성에 접근할 때마다 특정 메서드를 호출하도록 할 수 있어 속성 값을 읽거나 쓸 때 특정 로직을 실행할 수 있다.

기본 사용법

property 함수는 이를 위해 존재하며, 다음과 같은 네 가지 인자를 받을 수 있다.

1. fget: 속성 값을 읽을 때 호출되는 함수(getter)

2. fset: 속성 값을 설정할 때 호출되는 함수(setter)

3. fdel: 속성 값을 삭제할 때 호출되는 함수(deleter)

4. doc: 속성에 대한 문서화 문자열

다음 예제를 통해 데코레이터 없이 property를 정의하는 방법을 살펴보자.

class Circle:
    def __init__(self, radius):
        self._radius = radius

    def get_radius(self):
        return self._radius

    def set_radius(self, value):
        if value < 0:
            raise ValueError("반지름은 0보다 커야 합니다.")
        self._radius = value

    def del_radius(self):
        del self._radius

    radius = property(get_radius, set_radius, del_radius, "원의 반지름을 나타내는 속성")

# 사용 예시
circle = Circle(5)
print(circle.radius)  # 5

circle.radius = 10
print(circle.radius)  # 10

try:
    circle.radius = -3  # ValueError 발생
except ValueError as e:
    print(e)

del circle.radius
try:
    print(circle.radius)  # AttributeError 발생
except AttributeError as e:
    print(e)

• fget: 속성 값을 읽을 때 호출되는 함수. 예제에서는 get_radius 함수가 해당된다.

• fset: 속성 값을 설정할 때 호출되는 함수. 예제에서는 set_radius 함수가 해당된다.

• fdel: 속성 값을 삭제할 때 호출되는 함수. 예제에서는 del_radius 함수가 해당된다.

• doc: 속성에 대한 문서화 문자열. 예제에서는 "원의 반지름을 나타내는 속성"가 해당된다.

@property

@property 데코레이터는 메서드를 속성처럼 사용할 수 있게 한다. 이는 getter 메서드를 정의할 때 사용된다.

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

이렇게 하면 value 속성에 접근할 때마다 self._value 값을 반환하는 value 메서드가 호출된다.

@property.setter

@property.setter 데코레이터는 속성에 값을 설정할 때 호출되는 setter 메서드를 정의한다.

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

이렇게 하면 value 속성에 값을 설정할 때 value 메서드가 호출되어 _value 속성 값을 갱신하게 된다.

@property.deleter

@property.deleter 데코레이터는 속성을 삭제할 때 호출되는 deleter 메서드를 정의한다.

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        self._value = new_value

    @value.deleter
    def value(self):
        del self._value

이렇게 하면 value 속성을 삭제할 때 value 메서드가 호출되어 _value 속성을 삭제하게 된다.

응용 예제

이제 property의 좀 더 실용적인 응용 예제를 살펴보자. 예를 들어, 온도를 섭씨와 화씨로 변환하는 클래스를 만들어 보자.

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        self._celsius = value

    @property
    def fahrenheit(self):
        return (self._celsius * 9/5) + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5/9

# 사용 예시
temp = Temperature(25)
print(temp.celsius)  # 25
print(temp.fahrenheit)  # 77.0

temp.fahrenheit = 98.6
print(temp.celsius)  # 37.0
print(temp.fahrenheit)  # 98.6

위 예제에서 fahrenheit 속성은 getter와 setter 메서드를 통해 자동으로 섭씨와 화씨 값을 변환해준다. 이처럼 property를 사용하면 코드의 가독성과 유지보수성을 크게 향상시킬 수 있다.

상속은 객체 지향 프로그래밍에서 중요한 개념 중 하나로, 기존 클래스(부모 클래스 또는 슈퍼 클래스)의 속성과 메서드를 새로운 클래스(자식 클래스 또는 서브 클래스)가 물려받아 사용하는 것을 말한다. 이를 통해 코드의 재사용성을 높이고, 유지보수를 용이하게 한다.

기본 개념

상속은 다음과 같은 기본 개념을 포함한다:

• 부모 클래스 (Parent Class): 다른 클래스에게 속성과 메서드를 물려주는 클래스.

• 자식 클래스 (Child Class): 부모 클래스로부터 속성과 메서드를 물려받는 클래스.

예제 코드

부모 클래스 정의

class Animal:
    def __init__(self, name):
        self.name = name
    
    def speak(self):
        print(f"{self.name}가 소리를 낸다.")

자식 클래스 정의

부모 클래스 Animal을 상속받는 자식 클래스 Dog와 Cat을 정의해보자.

class Dog(Animal):
    def speak(self):
        print(f"{self.name}가 멍멍 짖는다.")

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

객체 생성 및 메서드 호출

dog = Dog("바둑이")
cat = Cat("나비")

dog.speak()  # 출력: 바둑이가 멍멍 짖는다.
cat.speak()  # 출력: 나비가 야옹 야옹 운다.

상속의 장점

1. 코드 재사용: 부모 클래스에서 정의한 속성과 메서드를 자식 클래스에서 다시 정의할 필요 없이 사용할 수 있다.

2. 유지보수 용이: 공통된 기능을 부모 클래스에 두고, 각 클래스는 고유한 기능만 추가로 구현하면 되므로 유지보수가 쉽다.

3. 계층 구조 표현: 상속을 통해 클래스 간의 계층 구조를 명확히 표현할 수 있다.

상속의 종류

단일 상속 (Single Inheritance): 단일 상속은 하나의 부모 클래스만을 상속받는 방식이다. 위의 예제는 단일 상속의 예이다.

다중 상속 (Multiple Inheritance): 다중 상속은 두 개 이상의 부모 클래스를 상속받는 방식이다. 파이썬은 다중 상속을 지원한다.

class Animal:
    def __init__(self, name):
        self.name = name
    
    def move(self):
        print(f"{self.name}가 움직인다.")

class Pet:
    def __init__(self, owner):
        self.owner = owner

    def show_owner(self):
        print(f"주인은 {self.owner}이다.")

class Dog(Animal, Pet):
    def __init__(self, name, owner):
        Animal.__init__(self, name)
        Pet.__init__(self, owner)
    
    def speak(self):
        print(f"{self.name}가 멍멍 짖는다.")

dog = Dog("바둑이", "철수")
dog.speak()        # 출력: 바둑이가 멍멍 짖는다.
dog.move()         # 출력: 바둑이가 움직인다.
dog.show_owner()   # 출력: 주인은 철수이다.

메서드 오버라이딩 (Method Overriding)

자식 클래스에서 부모 클래스의 메서드를 재정의(오버라이딩)할 수 있다. 오버라이딩된 메서드는 부모 클래스의 메서드 대신 호출된다.

class Animal:
    def speak(self):
        print("동물이 소리를 낸다.")

class Dog(Animal):
    def speak(self):
        print("강아지가 멍멍 짖는다.")

dog = Dog()
dog.speak()  # 출력: 강아지가 멍멍 짖는다.

super() 함수

super() 함수는 부모 클래스의 메서드를 호출할 때 사용된다. 이를 통해 자식 클래스에서 부모 클래스의 메서드를 확장할 수 있다.

class Animal:
    def speak(self):
        print("동물이 소리를 낸다.")

class Dog(Animal):
    def speak(self):
        super().speak()  # 부모 클래스의 speak() 호출
        print("강아지가 멍멍 짖는다.")

dog = Dog()
dog.speak()
# 출력:
# 동물이 소리를 낸다.
# 강아지가 멍멍 짖는다.

파이썬에서 열거형(Enumeration) 또는 줄여서 열거형은 명명된 상수들의 집합을 정의하는 클래스이다. 열거형을 사용하면 코드의 가독성과 유지보수성을 높일 수 있으며, 의미 있는 이름을 통해 값들을 그룹화할 수 있다. 파이썬에서는 enum 모듈을 사용하여 열거형을 정의할 수 있다.

enum 모듈

enum 모듈은 열거형을 정의하기 위해 제공되며, Enum 클래스를 사용하여 열거형을 정의할 수 있다.

from enum import Enum

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

위 예제에서 Color는 Enum 클래스를 상속받아 정의된 열거형이다. RED, GREEN, BLUE는 열거형의 멤버이며, 각각 1, 2, 3의 값을 가진다.

열거형의 멤버 접근

열거형의 멤버는 점 표기법을 사용하여 접근할 수 있다.

print(Color.RED)  # Color.RED 출력
print(Color.GREEN)  # Color.GREEN 출력
print(Color.BLUE)  # Color.BLUE 출력

print(Color.RED.name)  # RED 출력
print(Color.RED.value)  # 1 출력

• Color.RED: 열거형 멤버 자체를 나타낸다.

• Color.RED.name: 열거형 멤버의 이름을 문자열로 반환한다.

• Color.RED.value: 열거형 멤버의 값을 반환한다.

열거형의 이터레이션

열거형은 이터러블(iterable)이다. 이를 통해 열거형의 모든 멤버를 반복(iterate)할 수 있다.

for color in Color:
    print(color)

위 코드는 Color 열거형의 모든 멤버를 순회하며 각각을 출력한다.

열거형의 비교

열거형 멤버는 동일한 열거형 내에서 비교할 수 있다.

print(Color.RED == Color.RED)  # True 출력
print(Color.RED == Color.BLUE)  # False 출력
print(Color.RED is Color.RED)  # True 출력
print(Color.RED is Color.BLUE)  # False 출력

열거형의 활용

열거형은 코드에서 의미 있는 상수 값을 정의할 때 유용하다. 예를 들어, 상태 코드, 방향, 옵션 등을 정의하는 데 사용할 수 있다.

from enum import Enum, auto

class Status(Enum):
    NEW = auto()
    IN_PROGRESS = auto()
    COMPLETED = auto()
    FAILED = auto()

# 상태 확인
print(Status.NEW)  # Status.NEW 출력
print(Status.IN_PROGRESS)  # Status.IN_PROGRESS 출력

# 열거형의 이름과 값
print(Status.NEW.name)  # NEW 출력
print(Status.NEW.value)  # 1 출력

# 상태 비교
current_status = Status.IN_PROGRESS
if current_status == Status.IN_PROGRESS:
    print("현재 작업이 진행 중입니다.")

위 예제에서 Status 열거형은 작업의 상태를 나타내며, auto()를 사용하여 자동으로 값을 할당한다. 이는 값이 중요한 것이 아니라 상태를 의미 있는 이름으로 구분하는 것이 중요할 때 유용하다.

열거형 멤버의 속성과 메서드

열거형 멤버는 다양한 속성과 메서드를 제공한다.

• name: 열거형 멤버의 이름을 반환한다.

• value: 열거형 멤버의 값을 반환한다.

• __members__: 열거형의 모든 멤버를 사전(dictionary) 형태로 반환한다.

# 모든 멤버 확인
print(Status.__members__)  # {'NEW': <Status.NEW: 1>, 'IN_PROGRESS': <Status.IN_PROGRESS: 2>, 'COMPLETED': <Status.COMPLETED: 3>, 'FAILED': <Status.FAILED: 4>} 출력

파이썬 클래스에서 스페셜 메서드(Special Methods) 또는 매직 메서드(Magic Methods)는 특정 상황에서 자동으로 호출되는 특별한 메서드들이다. 이러한 메서드는 이중 밑줄(__)로 시작하고 끝나며, 객체의 특수한 동작을 정의하는 데 사용된다. 스페셜 메서드는 클래스의 인스턴스가 기본 데이터 타입처럼 동작할 수 있게 해준다.

주요 스페셜 메서드

__init__(self, ...) - 초기화 메서드

• 객체가 생성될 때 호출되어 인스턴스 변수를 초기화한다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

__str__(self) - 문자열 표현

• print() 함수로 객체를 출력할 때 호출되어 사람이 읽기 쉬운 형태로 반환한다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name}, {self.age}살"

person = Person("홍길동", 30)
print(person)  # 홍길동, 30살 출력

__repr__(self) - 공식 문자열 표현

• 객체의 “공식적인” 문자열 표현을 반환하며, 주로 디버깅을 위해 사용된다. repr() 함수나 인터프리터에서 객체를 출력할 때 호출된다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __repr__(self):
        return f"Person(name={self.name}, age={self.age})"

person = Person("홍길동", 30)
print(repr(person))  # Person(name=홍길동, age=30) 출력

__len__(self) - 길이 반환

• len() 함수가 호출될 때 객체의 길이를 반환한다.

class CustomList:
    def __init__(self, items):
        self.items = items

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

custom_list = CustomList([1, 2, 3, 4, 5])
print(len(custom_list))  # 5 출력

__getitem__(self, key) - 인덱싱

• 객체가 인덱싱될 때 호출되어 해당 키에 해당하는 값을 반환한다.

class CustomList:
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return self.items[index]

custom_list = CustomList([1, 2, 3, 4, 5])
print(custom_list[2])  # 3 출력

__setitem__(self, key, value) - 인덱싱을 통한 값 설정

• 객체의 특정 키에 값을 설정할 때 호출된다.

class CustomList:
    def __init__(self, items):
        self.items = items

    def __getitem__(self, index):
        return self.items[index]

    def __setitem__(self, index, value):
        self.items[index] = value

custom_list = CustomList([1, 2, 3, 4, 5])
custom_list[2] = 10
print(custom_list[2])  # 10 출력

__delitem__(self, key) - 인덱싱을 통한 값 삭제

• 객체의 특정 키에 해당하는 값을 삭제할 때 호출된다.

class CustomList:
    def __init__(self, items):
        self.items = items

    def __delitem__(self, index):
        del self.items[index]

custom_list = CustomList([1, 2, 3, 4, 5])
del custom_list[2]
print(custom_list.items)  # [1, 2, 4, 5] 출력

__call__(self, ...) - 함수처럼 호출

• 객체가 함수처럼 호출될 때 실행된다.

class Adder:
    def __init__(self, value):
        self.value = value

    def __call__(self, x):
        return self.value + x

adder = Adder(10)
print(adder(5))  # 15 출력

__eq__ 메서드 - 동등성 비교

__eq__ 메서드는 두 객체의 동등성을 비교하기 위해 사용된다. 이 메서드는 == 연산자가 사용될 때 호출된다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

# 객체 생성
person1 = Person("홍길동", 30)
person2 = Person("홍길동", 30)
person3 = Person("김철수", 25)

# 동등성 비교
print(person1 == person2)  # True 출력
print(person1 == person3)  # False 출력

__hash__ 메서드 - 해시 반환

__hash__ 메서드는 객체의 해시 값을 반환하며, 해시 테이블에서 객체를 사용할 수 있도록 한다. 해시 값은 set과 dict와 같은 해시 기반 컬렉션에서 객체를 키로 사용할 때 필요하다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        if isinstance(other, Person):
            return self.name == other.name and self.age == other.age
        return False

    def __hash__(self):
        return hash((self.name, self.age))

# 객체 생성
person1 = Person("홍길동", 30)
person2 = Person("홍길동", 30)

# 해시 값 확인
print(hash(person1))  # 해시 값 출력
print(hash(person2))  # 동일한 해시 값 출력

# 집합에 객체 추가
people = {person1, person2}
print(len(people))  # 1 출력, 동등한 객체는 하나로 간주

인스턴스 프라이빗 변수는 클래스 내부에서만 접근할 수 있도록 설계된 변수로, 외부에서 직접 접근할 수 없도록 보호된 변수이다. 이러한 변수는 변수 이름 앞에 밑줄 두 개(__)를 붙여 정의된다. 이를 통해 변수의 이름이 변경(name mangling)되어 외부에서의 접근이 제한된다.

프라이빗 변수 정의 및 사용

프라이빗 변수는 클래스 내부에서 정의되며, 클래스 내부의 메서드를 통해 접근하고 조작할 수 있다. 외부에서 직접 접근하려고 하면 AttributeError가 발생한다.

class Person:
    def __init__(self, name, age):
        self.__name = name  # 프라이빗 변수
        self.__age = age  # 프라이빗 변수

    def get_name(self):
        return self.__name

    def set_name(self, name):
        self.__name = name

    def get_age(self):
        return self.__age

    def set_age(self, age):
        if age > 0:
            self.__age = age
        else:
            raise ValueError("나이는 양수여야 합니다.")

# 객체 생성
person = Person("홍길동", 30)

# 클래스 내부 메서드를 통해 접근
print(person.get_name())  # 홍길동 출력
print(person.get_age())  # 30 출력

# 프라이빗 변수 직접 접근 시도
try:
    print(person.__name)
except AttributeError as e:
    print(e)  # 'Person' object has no attribute '__name' 출력

위 예제에서 __name과 __age는 프라이빗 변수로 정의되었으며, 외부에서는 직접 접근할 수 없다. 대신 get_name, set_name, get_age, set_age 메서드를 통해 접근하고 값을 변경할 수 있다.

이름 장식 (Name Mangling)

파이썬은 프라이빗 변수에 접근을 제한하기 위해 이름 장식(name mangling)을 사용한다. 이는 변수 이름을 클래스 이름과 결합하여 변경하는 방식이다. 예를 들어, __name이라는 프라이빗 변수는 _Person__name으로 변경된다. 이를 통해 클래스 외부에서 우연히 접근하는 것을 방지한다.

# 이름 장식을 통한 프라이빗 변수 접근
print(person._Person__name)  # 홍길동 출력

위와 같이 클래스 이름을 이용해 프라이빗 변수에 접근할 수 있지만, 이는 일반적으로 권장되지 않는 방법이다.

프라이빗 변수를 사용하는 이유

1. 캡슐화(Encapsulation): 프라이빗 변수는 클래스 내부의 구현 세부 사항을 숨기고, 외부로부터 데이터를 보호하여 클래스의 일관성을 유지한다.

2. 데이터 보호: 중요한 데이터나 내부 상태를 보호하여 무분별한 접근과 수정으로부터 객체를 보호한다.

3. 유지보수 용이성: 클래스의 내부 구현이 변경되더라도 외부 코드에 영향을 미치지 않도록 하여 코드의 유지보수를 쉽게 한다.

__init__ 함수는 파이썬 클래스에서 객체가 생성될 때 자동으로 호출되는 초기화 메서드이다. 이 메서드는 객체의 속성을 초기화하고, 객체 생성 시 필요한 초기 설정을 수행한다. __init__ 메서드는 생성자(constructor)라고도 한다.

__init__ 함수의 정의와 호출

__init__ 함수는 다음과 같은 형태로 정의된다.

class ClassName:
    def __init__(self, parameters):
        self.attribute = parameters

• self는 생성된 인스턴스를 참조하며, 인스턴스 메서드에서 항상 첫 번째 매개변수로 사용된다.

• parameters는 객체를 생성할 때 필요한 값을 전달받는다.

객체를 생성할 때, __init__ 함수는 자동으로 호출되며, 전달된 인수들은 self를 통해 인스턴스 변수로 저장된다.

예제: __init__ 함수 사용

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"안녕하세요, 제 이름은 {self.name}이고, 저는 {self.age}살입니다."

# 객체 생성
person1 = Person("홍길동", 30)
person2 = Person("김철수", 25)

# 메서드 호출
print(person1.greet())  # 안녕하세요, 제 이름은 홍길동이고, 저는 30살입니다. 출력
print(person2.greet())  # 안녕하세요, 제 이름은 김철수이고, 저는 25살입니다. 출력

위 예제에서 Person 클래스는 __init__ 메서드를 사용하여 객체 생성 시 이름과 나이를 초기화한다.

__init__ 함수의 역할

1. 객체 초기화: __init__ 함수는 객체가 생성될 때 초기화 작업을 수행한다.

2. 인스턴스 변수 설정: 객체의 속성을 정의하고 초기값을 설정한다.

3. 초기 설정: 객체 생성 시 필요한 초기 설정을 수행한다.

__init__ 함수와 __new__ 함수의 차이

• __new__ 함수는 객체의 인스턴스를 생성하는 역할을 하며, 클래스 자체에서 호출된다. __new__ 함수는 매우 드물게 사용되며, 주로 불변 객체(immutable object)를 생성할 때 사용된다.

• __init__ 함수는 생성된 객체를 초기화하는 역할을 하며, self를 통해 인스턴스를 참조한다.

class Example:
    def __new__(cls, *args, **kwargs):
        print("Creating instance")
        instance = super().__new__(cls)
        return instance

    def __init__(self, value):
        print("Initializing instance")
        self.value = value

# 객체 생성
example = Example(42)

파이썬에서 메서드(Method)와 함수(Function)는 중요한 개념으로, 둘 다 코드의 재사용성과 구조화를 돕는다. 하지만 이 둘은 사용하는 맥락과 동작 방식에서 차이가 있다.

메서드 (Method)

메서드는 클래스 내부에 정의된 함수로, 클래스의 인스턴스나 클래스 자체와 연관된 동작을 정의한다. 메서드는 클래스의 인스턴스에 바인딩되며, 첫 번째 매개변수로 항상 self (또는 클래스 메서드의 경우 cls)를 받는다.

인스턴스 메서드 (Instance Method)

• 클래스의 인스턴스와 관련된 동작을 정의한다.

• 첫 번째 매개변수로 self를 받는다.

• 인스턴스 변수와 메서드에 접근할 수 있다.

class Person:
    def __init__(self, name):
        self.name = name
    
    def greet(self):
        return f"안녕하세요, {self.name}님!"

# 인스턴스 메서드 호출
person = Person("홍길동")
print(person.greet())  # 안녕하세요, 홍길동님! 출력

클래스 메서드 (Class Method)

• 클래스 자체와 관련된 동작을 정의한다.

• 첫 번째 매개변수로 cls를 받는다.

• 클래스 변수와 클래스 메서드에 접근할 수 있다.

• @classmethod 데코레이터를 사용하여 정의한다.

class Person:
    population = 0

    def __init__(self, name):
        self.name = name
        Person.population += 1

    @classmethod
    def get_population(cls):
        return f"총 인구수는 {cls.population}명입니다."

# 클래스 메서드 호출
print(Person.get_population())  # 총 인구수는 0명입니다. 출력

정적 메서드 (Static Method)

• 클래스나 인스턴스와 독립적으로 동작한다.

• 첫 번째 매개변수로 self나 cls를 받지 않는다.

• @staticmethod 데코레이터를 사용하여 정의한다.

class Math:
    @staticmethod
    def add(a, b):
        return a + b

# 정적 메서드 호출
print(Math.add(3, 5))  # 8 출력

함수 (Function)

클래스 내부에 정의된 일반 함수는 특정 인스턴스나 클래스와 직접 연관되지 않으며, 독립적인 작업을 수행하기 위해 정의될 수 있다. 그러나 일반적으로 클래스 내부에는 메서드만 정의하고, 함수는 클래스 외부에 정의한다.

클래스 내부에 정의된 함수는 클래스나 인스턴스의 맥락에서 동작하지 않기 때문에 일반적으로 클래스 외부에 두는 것이 좋다.

class Example:
    def instance_method(self):
        return "인스턴스 메서드 호출됨"

    @classmethod
    def class_method(cls):
        return "클래스 메서드 호출됨"

    @staticmethod
    def static_method():
        return "정적 메서드 호출됨"

    def regular_function():
        return "이것은 함수이며, 클래스나 인스턴스와 연관되지 않음"

# 객체 생성
example = Example()

# 인스턴스 메서드 호출
print(example.instance_method())  # 인스턴스 메서드 호출됨 출력

# 클래스 메서드 호출
print(Example.class_method())  # 클래스 메서드 호출됨 출력

# 정적 메서드 호출
print(Example.static_method())  # 정적 메서드 호출됨 출력

# 클래스 내부에 정의된 함수는 호출 불가
try:
    print(example.regular_function())
except TypeError as e:
    print(e)  # TypeError: regular_function() takes 0 positional arguments but 1 was given 출력

위 예제에서 regular_function은 클래스 내부에 정의되었지만 인스턴스나 클래스와 연결되지 않기 때문에 호출 시 에러가 발생한다. 이 함수는 클래스 내부에서 잘못된 위치에 정의된 것으로 볼 수 있으며, 클래스 외부에 정의하는 것이 더 적절하다.

정리

• 메서드(Method): 클래스 내부에 정의되며, 인스턴스 또는 클래스와 관련된 동작을 정의한다. 인스턴스 메서드, 클래스 메서드, 정적 메서드로 구분된다.

• 함수(Function): 일반적으로 클래스 외부에 정의되며, 특정 작업을 수행하기 위한 독립적인 코드 블록이다. 클래스 내부에서 정의된 일반 함수는 메서드와 달리 클래스나 인스턴스와 관련이 없다.

파이썬에서 클래스 내부에 정의된 함수와 메서드는 객체 지향 프로그래밍(OOP)의 중요한 부분이다. 클래스 내부에서 정의된 함수는 클래스와 인스턴스의 행동을 정의하는 데 사용된다.

1. 인스턴스 메서드 (Instance Method)

인스턴스 메서드는 클래스의 인스턴스에 대해 동작하며, 첫 번째 매개변수로 항상 self를 받는다. self는 해당 메서드가 호출된 인스턴스를 참조한다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"안녕하세요, {self.name}님! 저는 {self.age}살입니다."

# 객체 생성 및 메서드 호출
person = Person("홍길동", 30)
print(person.greet())  # 안녕하세요, 홍길동님! 저는 30살입니다. 출력

2. 클래스 메서드 (Class Method)

클래스 메서드는 클래스 자체를 대상으로 동작하며, 첫 번째 매개변수로 cls를 받는다. cls는 해당 메서드가 호출된 클래스를 참조한다. 클래스 메서드는 @classmethod 데코레이터로 정의된다.

class Person:
    population = 0  # 클래스 변수

    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.population += 1

    @classmethod
    def get_population(cls):
        return f"총 인구수는 {cls.population}명입니다."

# 객체 생성
person1 = Person("홍길동", 30)
person2 = Person("김철수", 25)

# 클래스 메서드 호출
print(Person.get_population())  # 총 인구수는 2명입니다. 출력

3. 정적 메서드 (Static Method)

정적 메서드는 클래스나 인스턴스와 관계없이 독립적으로 동작한다. 첫 번째 매개변수로 self나 cls를 받지 않는다. 정적 메서드는 @staticmethod 데코레이터로 정의된다.

class Circle:
    pi = 3.14159  # 클래스 변수

    def __init__(self, radius):
        self.radius = radius  # 인스턴스 변수

    def area(self):
        return Circle.pi * (self.radius ** 2)  # 인스턴스 메서드

    @classmethod
    def change_pi(cls, new_pi):
        cls.pi = new_pi  # 클래스 메서드

    @staticmethod
    def describe():
        return "이 클래스는 원의 넓이와 관련된 메서드를 포함합니다."  # 정적 메서드

# 객체 생성
circle = Circle(5)

# 인스턴스 메서드 호출
print(circle.area())  # 78.53975 출력

# 클래스 메서드 호출
Circle.change_pi(3.14)
print(circle.area())  # 78.5 출력

# 정적 메서드 호출
print(Circle.describe())  # 이 클래스는 원의 넓이와 관련된 메서드를 포함합니다. 출력

클래스 변수는 클래스의 모든 인스턴스(instance)들이 공유하는 변수이다. 인스턴스 변수와 달리, 클래스 변수는 클래스 자체에 속하며, 모든 인스턴스가 동일한 값을 가진다.

클래스 변수 정의 및 사용

클래스 변수는 클래스 블록 안에 직접 정의된다. 클래스 변수를 정의한 후에는 클래스 이름을 통해 접근하거나, 인스턴스 이름을 통해 접근할 수 있다.

class Person:
    species = "Homo sapiens"  # 클래스 변수

    def __init__(self, name, age):
        self.name = name  # 인스턴스 변수
        self.age = age  # 인스턴스 변수

# 클래스 변수를 클래스 이름을 통해 접근
print(Person.species)  # Homo sapiens 출력

# 객체 생성
person1 = Person("홍길동", 30)
person2 = Person("김철수", 25)

# 클래스 변수를 인스턴스를 통해 접근
print(person1.species)  # Homo sapiens 출력
print(person2.species)  # Homo sapiens 출력

# 클래스 변수의 값 변경
Person.species = "Human"

# 변경된 클래스 변수 값 확인
print(person1.species)  # Human 출력
print(person2.species)  # Human 출력
print(Person.species)  # Human 출력

클래스 변수와 인스턴스 변수의 차이

• 클래스 변수: 클래스 자체에 속하며, 모든 인스턴스가 공유한다.

• 인스턴스 변수: 개별 인스턴스에 속하며, 각 인스턴스마다 고유한 값을 가진다.

class Dog:
    species = "Canis lupus"  # 클래스 변수

    def __init__(self, name):
        self.name = name  # 인스턴스 변수

dog1 = Dog("Max")
dog2 = Dog("Buddy")

# 인스턴스 변수는 각 인스턴스마다 다를 수 있다.
print(dog1.name)  # Max 출력
print(dog2.name)  # Buddy 출력

# 클래스 변수는 모든 인스턴스가 공유한다.
print(dog1.species)  # Canis lupus 출력
print(dog2.species)  # Canis lupus 출력

# 클래스 변수 값 변경
Dog.species = "Canis familiaris"
print(dog1.species)  # Canis familiaris 출력
print(dog2.species)  # Canis familiaris 출력

getattr 함수

getattr 함수는 객체에서 속성의 값을 반환한다. 만약 속성이 존재하지 않으면 AttributeError를 발생시키거나, 기본값을 반환할 수 있다.

class Car:
    brand = "Toyota"  # 클래스 변수

# 클래스 변수 조회
print(getattr(Car, 'brand'))  # Toyota 출력

# 존재하지 않는 속성 조회
print(getattr(Car, 'model', 'Unknown'))  # Unknown 출력

setattr 함수

setattr 함수는 객체에 속성을 설정한다. 속성이 존재하지 않으면 새로운 속성을 추가한다.

class Car:
    brand = "Toyota"  # 클래스 변수

# 클래스 변수 설정
setattr(Car, 'brand', 'Honda')
print(Car.brand)  # Honda 출력

# 새로운 클래스 변수 추가
setattr(Car, 'model', 'Civic')
print(Car.model)  # Civic 출력

delattr 함수

delattr 함수는 객체에서 속성을 삭제한다. 만약 속성이 존재하지 않으면 AttributeError를 발생시킨다.

class Car:
    brand = "Toyota"  # 클래스 변수

# 클래스 변수 삭제
delattr(Car, 'brand')

# 삭제된 속성 접근 시도
try:
    print(Car.brand)
except AttributeError as e:
    print(e)  # type object 'Car' has no attribute 'brand' 출력

클래스 및 인스턴스의 __dict__ 속성

__dict__ 속성은 객체의 모든 속성과 그 값을 포함하는 딕셔너리를 반환한다. 이를 통해 클래스 변수와 인스턴스 변수를 쉽게 확인할 수 있다.

class Animal:
    kingdom = "Animalia"  # 클래스 변수

    def __init__(self, name):
        self.name = name  # 인스턴스 변수

# 클래스의 __dict__ 조회
print(Animal.__dict__)

# 인스턴스의 __dict__ 조회
animal1 = Animal("Tiger")
print(animal1.__dict__)

클래스(Class)는 객체 지향 프로그래밍(OOP)의 기본 개념 중 하나로, 객체를 생성하기 위한 설계도이다. 객체는 클래스의 인스턴스(instance)라고도 한다. 클래스는 데이터 속성(attribute)과 메서드(method)를 포함할 수 있으며, 이를 통해 객체의 상태(state)와 행동(behavior)을 정의한다.

클래스 정의하기

클래스를 정의하려면 class 키워드를 사용한다. 클래스의 이름은 일반적으로 대문자로 시작한다.

class Person:
    pass

위 예제는 Person이라는 빈 클래스를 정의한 것이다. pass 키워드는 아무것도 하지 않는 문장을 의미한다.

속성과 메서드 추가하기

클래스에 속성과 메서드를 추가하여 객체의 상태와 행동을 정의할 수 있다.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        return f"안녕하세요, 제 이름은 {self.name}이고, 저는 {self.age}살입니다."

• __init__ 메서드는 생성자(constructor)로, 객체가 생성될 때 호출된다. 여기서 self는 생성된 객체를 참조한다.

• self.name과 self.age는 인스턴스 속성(instance attribute)이다.

• greet 메서드는 인사말을 반환한다.

객체 생성하기

클래스로부터 객체를 생성하려면 클래스 이름을 함수처럼 호출하면 된다.

person1 = Person("홍길동", 30)
print(person1.greet())

위 코드는 홍길동이라는 이름과 30살의 나이를 가진 Person 객체를 생성하고, greet 메서드를 호출하여 인사말을 출력한다.

속성 접근 및 수정

객체의 속성에 접근하거나 속성을 수정할 수 있다.

print(person1.name)  # 홍길동 출력
person1.age = 31
print(person1.greet())  # "안녕하세요, 제 이름은 홍길동이고, 저는 31살입니다." 출력

예제: 은행 계좌 클래스

다음은 은행 계좌를 모델링한 클래스 예제이다.

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

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            return f"{amount}원이 입금되었습니다. 현재 잔액: {self.balance}원"
        return "입금할 금액이 유효하지 않습니다."

    def withdraw(self, amount):
        if 0 < amount <= self.balance:
            self.balance -= amount
            return f"{amount}원이 출금되었습니다. 현재 잔액: {self.balance}원"
        return "출금할 금액이 유효하지 않거나 잔액이 부족합니다."

# 객체 생성 및 메서드 호출
account = BankAccount("김철수", 1000)
print(account.deposit(500))  # 500원이 입금되었습니다. 현재 잔액: 1500원 출력
print(account.withdraw(200))  # 200원이 출금되었습니다. 현재 잔액: 1300원 출력
print(account.withdraw(2000))  # 출금할 금액이 유효하지 않거나 잔액이 부족합니다. 출력

위 예제에서 BankAccount 클래스는 은행 계좌의 소유자와 잔액을 속성으로 가지며, 입금과 출금을 처리하는 메서드를 제공한다.

객체지향 프로그래밍(Object-Oriented Programming, OOP)은 프로그래밍 패러다임 중 하나로, 데이터를 객체로 모델링하고 이 객체들이 서로 상호작용하며 프로그램이 동작하도록 구성하는 방식이다. Python은 객체지향 프로그래밍을 강력하게 지원하며, 이를 통해 코드의 재사용성과 유지보수성을 높일 수 있다.

객체와 클래스

• 객체(Object): 실제로 존재하는 구체적인 실체를 말한다. 예를 들어, '고양이'는 하나의 객체가 될 수 있다.

• 클래스(Class): 객체를 만들기 위한 설계도나 틀을 의미한다. 즉, 객체의 속성과 행동을 정의하는 청사진이다.

클래스 정의와 객체 생성

클래스를 정의하고 이를 통해 객체를 생성하는 기본적인 방법을 살펴보자.

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    def bark(self):
        print(f"{self.name}가 짖는다: 멍멍!")

# 객체 생성
my_dog = Dog("바둑이", "진돗개")
my_dog.bark()

위 예제에서 Dog 클래스는 name과 breed라는 두 개의 속성을 가지고 있으며, bark라는 메서드를 가지고 있다. __init__ 메서드는 생성자로, 객체가 생성될 때 호출되어 객체의 초기 상태를 설정한다.

실생활 예제: 도서관 시스템

실생활에 적합한 예제로 도서관 시스템을 모델링해보자. 도서관에는 책, 회원, 대출 등이 있을 수 있다.

class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
        self.is_checked_out = False

    def check_out(self):
        if not self.is_checked_out:
            self.is_checked_out = True
            print(f"{self.title}이(가) 대출되었습니다.")
        else:
            print(f"{self.title}은(는) 이미 대출 중입니다.")

    def return_book(self):
        if self.is_checked_out:
            self.is_checked_out = False
            print(f"{self.title}이(가) 반납되었습니다.")
        else:
            print(f"{self.title}은(는) 대출되지 않았습니다.")

class Member:
    def __init__(self, name):
        self.name = name
        self.borrowed_books = []

    def borrow_book(self, book):
        if book not in self.borrowed_books:
            book.check_out()
            self.borrowed_books.append(book)
        else:
            print(f"{self.name}은(는) 이미 {book.title}을(를) 대출했습니다.")

    def return_book(self, book):
        if book in self.borrowed_books:
            book.return_book()
            self.borrowed_books.remove(book)
        else:
            print(f"{self.name}은(는) {book.title}을(를) 대출하지 않았습니다.")

# 객체 생성 및 사용 예제
book1 = Book("파이썬 마스터하기", "홍길동")
member1 = Member("김철수")

member1.borrow_book(book1)
member1.return_book(book1)

이 예제에서는 Book 클래스와 Member 클래스를 정의하였다. Book 클래스는 책의 제목과 저자, 대출 상태를 속성으로 가지며, 대출 및 반납 기능을 메서드로 제공한다. Member 클래스는 회원의 이름과 대출한 책 목록을 속성으로 가지며, 책을 대출하고 반납하는 기능을 메서드로 제공한다.

상속

상속은 객체지향 프로그래밍의 중요한 특징 중 하나로, 기존 클래스(부모 클래스)를 기반으로 새로운 클래스(자식 클래스)를 만들 수 있게 한다. 이를 통해 코드의 재사용성을 높일 수 있다.

class Librarian(Member):
    def __init__(self, name, employee_id):
        super().__init__(name)
        self.employee_id = employee_id

    def manage_books(self, book, action):
        if action == "check_out":
            book.check_out()
        elif action == "return":
            book.return_book()

# 사서 객체 생성 및 사용 예제
librarian = Librarian("이사서", 1001)
librarian.manage_books(book1, "check_out")
librarian.manage_books(book1, "return")

다형성

다형성은 동일한 인터페이스를 통해 다양한 객체를 처리할 수 있게 하는 객체지향 프로그래밍의 특징이다.

class EBook(Book):
    def __init__(self, title, author, file_size):
        super().__init__(title, author)
        self.file_size = file_size

    def display_file_size(self):
        print(f"파일 크기: {self.file_size}MB")

# 전자책 객체 생성 및 사용 예제
ebook = EBook("파이썬 프로그래밍", "이몽룡", 5)
ebook.check_out()
ebook.display_file_size()

위 예제에서 EBook 클래스는 Book 클래스를 상속받아 정의되었으며, 추가로 파일 크기 속성을 가지고 있다. EBook 객체는 Book 객체와 동일한 인터페이스를 통해 사용될 수 있다.

파이썬에서 __all__은 모듈이 from module import * 구문을 사용할 때, 외부에 공개할 객체의 리스트를 정의하는 특별한 변수이다. 이를 통해 모듈이 외부에 노출하는 인터페이스를 명확히 할 수 있다. __all__에 정의되지 않은 객체는 from module import * 구문으로 임포트되지 않는다.

기본 개념

__all__ 변수는 모듈의 네임스페이스에 정의된 공개 객체의 이름을 문자열로 포함하는 리스트이다. 이를 통해 모듈이 공개할 객체를 명시적으로 정의할 수 있다.

다음은 __all__의 기본 사용 예제이다.

mymodule.py

__all__ = ['public_function']

def public_function():
    print("This is a public function.")

def _private_function():
    print("This is a private function.")

main.py

from mymodule import *

public_function()  # This is a public function.
# _private_function()  # NameError: name '_private_function' is not defined

• __all__ 리스트에 public_function만 포함되어 있기 때문에, from mymodule import * 구문은 하나의 객체만 임포트한다.

• _private_function는 __all__ 리스트에 포함되지 않았기 때문에 임포트되지 않으며, main.py에서 접근할 수 없다.

__all__의 장점

1. 명확한 인터페이스 정의: __all__을 사용하면 모듈이 외부에 공개할 객체를 명확히 정의할 수 있어, 모듈의 공용 인터페이스를 쉽게 파악할 수 있다.

2. 캡슐화 강화: 중요한 내부 구현 세부 사항을 숨길 수 있어, 모듈의 사용자가 의도하지 않은 내부 객체에 접근하지 않도록 할 수 있다.

3. 코드 유지보수성 향상: 모듈의 외부 인터페이스를 명확히 정의함으로써, 모듈을 수정할 때 의도하지 않은 외부 영향(다른 모듈이나 코드에 미치는 영향)을 줄일 수 있다.

주의사항

• __all__은 from module import * 구문에만 영향을 미친다. import module이나 from module import specific_name 구문에는 영향을 미치지 않는다.

• __all__에 정의되지 않은 객체도 여전히 직접 임포트할 수 있다. 예를 들어, from mymodule import _private_function은 여전히 유효하다.

• 모듈 내에서 밑줄(_)로 시작하는 이름은 관례적으로 프라이빗(내부용)으로 간주되지만, 이는 강제되지 않으며 __all__에 포함할 수도 있다.

main.py

from mymodule import _private_function

_private_function()  # This is a private function.

이 예제에서 _private_function은 __all__에 포함되지 않았지만, 직접 임포트하여 사용할 수 있다.

파이썬 패키지(Package)는 관련 모듈들을 디렉토리 구조로 조직화한 것이다. 패키지는 모듈들을 계층적으로 구성하여, 코드의 구조를 체계적으로 만들고 관리하기 쉽게 해준다. 패키지를 사용하면 네임스페이스를 구분할 수 있어, 동일한 이름의 모듈들이 서로 충돌하지 않게 된다.

패키지 구조

파이썬 패키지는 디렉토리 형태로 구성되며, 패키지의 각 디렉토리는 __init__.py 파일을 포함해야 한다. __init__.py 파일은 해당 디렉토리를 패키지로 인식하게 하는 역할을 한다. 이 파일은 비워둘 수 있지만, 패키지 초기화 코드나 하위 모듈을 포함할 수 있다.

예제 패키지 구조

my_package/
│
├── __init__.py
├── module1.py
└── sub_package/
    ├── __init__.py
    └── module2.py

위 구조에서 my_package는 패키지이고, sub_package는 my_package의 하위 패키지이다. module1.py와 module2.py는 각각의 패키지에 속한 모듈들이다.

패키지 및 모듈 임포트

패키지 및 모듈을 임포트하는 방법은 다음과 같다.

모듈 임포트

import my_package.module1

my_package.module1.some_function()

하위 패키지 모듈 임포트

import my_package.sub_package.module2 my_package.sub_package.module2.another_function()

init.py 파일 활용

__init__.py 파일은 패키지를 초기화하거나, 패키지 내 모듈을 편리하게 임포트할 수 있도록 설정하는 데 사용된다.

# my_package/__init__.py

from .module1 import some_function

이렇게 설정하면, 다음과 같이 패키지를 임포트하고 함수에 접근할 수 있다.

from my_package import some_function

some_function()

예제 패키지 작성

예제로 만들어볼 패키지 구조는 다음과 같다.

math_package/
│
├── __init__.py
├── basic_operations.py
└── advanced_operations.py

basic_operations.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

advanced_operations.py

def square(a):
    return a * a

def cube(a):
    return a * a * a

__init__.py

from .basic_operations import add, subtract
from .advanced_operations import square, cube

이제 패키지를 사용해보자.

from math_package import add, subtract, square, cube

print(add(3, 5))        # 8
print(subtract(10, 4))  # 6
print(square(3))        # 9
print(cube(2))          # 8

파이썬에서 __name__은 특수한 내장 변수로, 모듈의 이름을 나타낸다. 이는 파이썬 코드가 직접 실행되는지 아니면 다른 모듈에 의해 임포트되는지 구분하는 데 사용된다. 이를 통해 스크립트를 직접 실행할 때와 모듈로 임포트할 때의 동작을 다르게 할 수 있다.

__name__의 기본 개념

1. 직접 실행될 때: 파이썬 파일을 직접 실행하면, __name__ 변수의 값은 "__main__"이 된다.

2. 임포트될 때: 다른 파일에서 해당 파일을 모듈로 임포트하면, __name__ 변수의 값은 모듈의 실제 이름(파일 이름)이 된다.

예제

다음은 __name__의 동작을 설명하는 예제이다.

mymodule.py

def greet(name):
    return f"Hello, {name}!"

if __name__ == "__main__":
    # 이 블록은 직접 실행될 때만 실행된다.
    print(greet("Alice"))

main.py

import mymodule

print(mymodule.greet("Bob"))

실행 결과

mymodule.py를 직접 실행할 때:

$ python mymodule.py

Hello, Alice!

main.py를 실행할 때:

$ python main.py

Hello, Bob!

위 예제에서 mymodule.py는 직접 실행될 때와 main.py에 의해 임포트될 때 각각 다른 동작을 한다.

__name__ == "__main__"의 활용

__name__ == "__main__" 패턴은 다음과 같은 상황에서 유용하게 사용된다.

1. 테스트 코드 작성: 모듈에 포함된 테스트 코드를 모듈의 끝 부분에 작성하고, 이 코드는 해당 모듈이 직접 실행될 때만 동작하게 할 수 있다.

2. 모듈로서의 사용과 스크립트로서의 사용 구분: 모듈이 다른 코드에 의해 임포트될 때는 특정 코드를 실행하지 않도록 할 수 있다.

테스트 코드 작성 예시

def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

if __name__ == "__main__":
    # 테스트 코드
    print("Testing add function:")
    print(add(2, 3))  # 5
    print(add(5, 7))  # 12

    print("Testing multiply function:")
    print(multiply(2, 3))  # 6
    print(multiply(5, 7))  # 35

모듈로서의 사용 예시

utility.py

def greet(name):
    return f"Hello, {name}!"

if __name__ == "__main__":
    print(greet("Alice"))

app.py

import utility

print(utility.greet("Bob"))

이 경우, app.py를 실행하면 utility.py의 __name__ == "__main__" 블록 안의 코드는 실행되지 않고, greet 함수만 임포트되어 사용된다.

파이썬에서 모듈을 import할 때, 파이썬 인터프리터는 모듈을 찾기 위해 특정 디렉토리 경로들을 검색한다. 이 검색 경로들은 모듈 검색 경로(module search path)라고 불리며, 이는 sys 모듈의 path 변수에 저장되어 있다. 이 경로들은 파이썬이 모듈을 찾는 순서를 정의한다.

기본 검색 경로

파이썬 인터프리터가 모듈을 검색하는 기본 경로는 다음과 같다:

1. 현재 디렉토리 (Current Directory): 스크립트가 실행되는 현재 디렉토리.

2. PYTHONPATH 환경 변수: 사용자가 정의한 디렉토리 목록. 운영 체제의 환경 변수로 설정할 수 있다.

3. 표준 라이브러리 디렉토리 (Standard Library Directories): 파이썬 설치 디렉토리 내의 라이브러리 디렉토리들.

4. 사이트-패키지 디렉토리 (site-packages Directory): 서드 파티 패키지들이 설치되는 디렉토리.

sys.path

sys.path는 모듈 검색 경로를 담고 있는 리스트이다. 이를 통해 파이썬이 모듈을 검색할 때 참조하는 경로들을 확인하고 수정할 수 있다.

sys.path 확인

다음은 sys.path를 확인하는 예제이다.

import sys

for path in sys.path:
    print(path)

이 코드를 실행하면, 파이썬이 모듈을 검색하는 경로들이 출력된다.

/path/to/current/directory
/path/to/python/lib
/path/to/python/lib/site-packages
…

PYTHONPATH 환경 변수

PYTHONPATH 환경 변수는 모듈 검색 경로에 사용자 정의 경로를 추가할 때 사용된다. 이를 통해 파이썬 인터프리터가 모듈을 찾을 수 있도록 추가적인 디렉토리를 지정할 수 있다.

# PYTHONPATH 설정 (Unix/Mac)
export PYTHONPATH=/path/to/my/modules:$PYTHONPATH



# PYTHONPATH 설정 (Windows)
set PYTHONPATH=C:\path\to\my\modules;%PYTHONPATH%

sys.path 수정

프로그램 실행 중에 sys.path에 경로를 동적으로 추가할 수도 있다. 이는 특정 모듈이 특정 디렉토리에 있을 때 유용하다.

import sys

sys.path.append('/path/to/my/modules')

import mymodule

이 코드를 통해 /path/to/my/modules 디렉토리가 sys.path에 추가되고, mymodule을 임포트할 수 있게 된다.

모듈 검색 경로의 순서

모듈 검색 경로는 순서가 중요하다. 파이썬은 sys.path에 나열된 순서대로 디렉토리를 검색하며, 가장 먼저 찾은 모듈을 임포트한다. 따라서, 동일한 이름의 모듈이 여러 경로에 존재할 경우, sys.path의 앞부분에 있는 경로의 모듈이 임포트된다. 

이러한 이유 때문에 기본 모듈과 같은 이름으로 모듈 파일을 만들면, 나중에 기본 모듈을 import하려고 할때 정상적으로 import가 안될 수 있다. 그럴 때는 모듈 파일의 이름을 다른 이름으로 변경해서 사용하는 편이 좋다.

파이썬 모듈은 함수, 클래스, 변수 등을 모아 놓은 파일을 의미한다. 모듈을 사용하면 코드를 논리적인 단위로 나눌 수 있어 코드의 재사용성과 관리가 용이해진다. 모듈은 코드의 구조를 체계적으로 만들고, 다른 파일에서 쉽게 불러와 사용할 수 있게 한다.

모듈 생성

모듈은 단순히 .py 확장자를 가진 파이썬 파일이다. 예를 들어, mymodule.py라는 파일을 생성하고 다음과 같은 코드를 작성할 수 있다.

def greet(name):
    return f"Hello, {name}!"

def add(a, b):
    return a + b

다른 파일에서 이 모듈을 불러와 사용할 수 있다. 이를 위해 import 문을 사용한다.

import mymodule

print(mymodule.greet("Alice"))  # Hello, Alice!
print(mymodule.add(3, 5))       # 8

다양한 import 방식

모듈을 불러오는 방법에는 여러 가지가 있다.

1. 모듈 전체를 import

import mymodule

print(mymodule.greet("Alice"))
print(mymodule.add(3, 5))

2. 모듈에서 특정 함수만 import

from mymodule import greet, add

print(greet("Alice"))
print(add(3, 5))

3. 모듈 전체를 별칭(alias)으로 import

import mymodule as mm

print(mm.greet("Alice"))
print(mm.add(3, 5))

4. 모듈에서 특정 함수만 별칭으로 import

from mymodule import greet as g, add as a

print(g("Alice"))
print(a(3, 5))

표준 라이브러리 모듈

파이썬은 다양한 표준 라이브러리 모듈을 제공한다. 이러한 모듈들은 파이썬 설치 시 함께 제공되며, 별도의 설치 없이 사용할 수 있다.

예제: math 모듈

math 모듈은 수학 관련 함수와 상수를 제공한다.

import math

print(math.sqrt(16))   # 4.0
print(math.pi)         # 3.141592653589793

예제: random 모듈

random 모듈은 난수 생성을 위한 함수들을 제공한다.

import random

print(random.randint(1, 10))   # 1부터 10 사이의 임의의 정수
print(random.random())         # 0.0부터 1.0 사이의 임의의 부동 소수점 수

예제: datetime 모듈

datetime 모듈은 날짜와 시간 처리를 위한 함수들을 제공한다.

import datetime

now = datetime.datetime.now()
print(now)                     # 현재 날짜와 시간 출력
print(now.strftime("%Y-%m-%d"))# 날짜를 지정한 형식으로 출력