[Python]파이썬 클래스: 객체지향 프로그래밍의 핵심 이해하기

객체지향 프로그래밍(OOP)은 현실 세계의 모델을 프로그램으로 표현하는 프로그래밍 패러다임입니다. python은 이를 위해 클래스(Class)와 객체(Object)라는 개념을 제공합니다. 이번 포스팅에서는 python 클래스에 대해 자세히 알아보겠습니다.

≣ 목차

• 객체지향 프로그래밍🧬
• 클래스와 객체🍞
• 클래스 정의하기👩‍🍳
• 클래스 메서드와 인스턴스 메서드🍰
• 상속👪
• 핵심 내용👀

---

1. 객체지향 프로그래밍🧬

객체 지향 프로그래밍은 문제를 작게 나누고 객체를 만들며, 이를 조합하여 문제를 해결하는 방식입니다. 이러한 접근 방식은 복잡한 문제를 처리하는 데 유용하며, 기능을 개선하고 발전시킬 때도 해당 클래스만 수정하면 되므로 유지보수에 효율적입니다.

핵심 개념

• 문제 분해: 객체 재향 프로그래밍에서는 큰 문제를 작은 문제로 나누어 해결합니다. 각 문제는 객체로 표현되며, 이러한 객체는 특정 기능을 수행하고 정보를 저장합니다.
• 객체 생성: 객체는 클래스의 인스턴스입니다. 클래스는 객체를 생성하기 위한 틀로, 속성(데이터)과 메서드(기능)를 포함합니다. 객체는 클래스에 정의된 속성과 메서드를 이용하여 특정한 동작을 수행합니다.
• 객체 조합: 객체들은 서로 연결되어 작업을 수행하며, 이를 통해 전체 시스템이 작동합니다. 다양한 객체들을 조합하여 복잡한 문제를 해결할 수 있습니다.

장점

• 유지보수 용이: 객체 지향 프로그래밍은 코드를 모듈화 하고 재사용성을 높여 유지보수를 용이하게 만듭니다. 특정 클래스의 수정이 해당 클래스를 사용하는 다른 부분에 영향을 미치지 않습니다.
• 확장성: 객체 지향 프로그래밍은 기능을 추가하거나 변경할 때 유연성을 제공합니다. 새로운 클래스를 작성하거나 기존 클래스를 상속하여 기능을 확장할 수 있습니다.
• 코드 가독성: 객체 지향 프로그래밍은 코드를 분리하여 각 객체가 특정 기능을 수행하므로 코드의 가독성이 높아집니다. 이는 코드를 이해하고 유지보수하는 데 도움이 됩니다.

즉 객체 지향 프로그래밍은 복잡한 문제를 해결하는 데 효과적인 방법입니다. 객체를 중심으로 코드를 구성함으로써 유지보수성을 높이고 확장성을 갖추며, 코드의 가독성을 높여 개발과 유지보수를 보다 효율적으로 수행할 수 있습니다.

---

2. 클래스와 객체🍞

클래스는 객체를 생성하기 위한 틀이며, 객체는 해당 클래스의 인스턴스입니다. 클래스와 객체는 서로 긴밀하게 연결되어 있으며, 클래스는 객체를 생성하기 위한 청사진으로 볼 수 있습니다. 클래스는 속성과 메서드로 구성되어 있으며, 객체의 상태와 행동을 정의합니다.

• 클래스(class): 클래스는 똑같은 무엇인가를 계속해서 만들어 낼 수 있는 설계도로 생각할 수 있습니다. 예를 들어, 과자틀이나 붕어빵 틀과 같습니다. 이 설계도를 통해 객체를 생성할 수 있습니다.
• 객체(object): 객체는 클래스의 인스턴스로, 클래스에서 만들어진 구체적인 개체입니다. 붕어빵 틀에서 만들어진 실제 붕어빵과 같은 것으로, 각각의 객체는 고유의 특성을 가지고 있습니다. 파이썬에서는 문자, 정수, 실수, 함수 등 모두 객체입니다.
• 인스턴스(instance): 인스턴스는 특정 객체가 어떤 클래스의 객체인지를 관계 위주로 설명할 때 사용됩니다. 클래스와 연관하여 객체를 지칭할 때 인스턴스라고 합니다. 즉, 클래스로부터 생성된 객체를 의미합니다.
• 메서드(method): 메서드는 클래스 안에서 구현된 함수로, 특정한 기능을 수행합니다. 이는 개체의 동작을 정의하는 데 사용됩니다.

아래 형식을 기반으로 하면 클래스와 객체를 쉽게 정의하고 사용할 수 있습니다.

---

3.클래스 정의하기👩‍🍳

클래스는 객체를 만들기 위한 설계도입니다. 이 설계도에는 속성과 메서드로 구성되어 있습니다.
클래스가 정의되는 과정은 다음과 같습니다.

클래스 정의 형식:

• 클래스는 class 키워드로 시작하여 class 클래스이름: 과 같이 정의됩니다.
• 파이썬에서는 클래스 이름을 일반적으로 첫 글 자를 대문자로 하는 카멜케이스를 사용합니다.

메서드 정의:

• 클래스 내부에는 메서드(함수)가 정의됩니다.
• 메서드는 def 메서드이름(self, 매개변수): 와 같이 정의됩니다.
• 메서드의 첫 번째 매개변수는 self로 메서드를 호출한 객체(인스턴스)가 자동으로 전달됩니다.
• 메서드 내부에서는 인스턴스 변수를 정의하거나 다양한 작업을 수행할 수 있습니다.

인스턴스 생성 형식:

• 클래스를 이용하여 실제 객체(인스턴스)를 생성합니다.
• 인스턴스 생성은 인스턴스이름 = 클래스이름()과 같이 수행됩니다.
• 이때 클래스 이름을 호출하는 것은 해당 클래스의 생성자를 호출하는 것과 유사합니다.
• 클래스를 붕어빵 틀이라고 가정했을 때 인스턴스를 생성하는 것은 붕어빵을 굽는 행위와 유사합니다.

인스턴스 호출 형식:

• 인스턴스를 통해 클래스의 메서드를 호출할 수 있습니다.
• 메서드 호출은 인스턴스.메서드이름()과 같이 수행됩니다.
• 이때 메서드 호출 시에는 인스턴스 자체가 메서드의 첫 번째 매개변수인 self로 자동으로 전달됩니다.
• 메서드 호출은 객체가 가지는 기능을 실행하는 것과 유사합니다.

# 클래스 정의 형식
class 클래스이름:  # 파이썬에서는 클래스이름을 주로 대문자로 시작
     def 메서드이름(self, 매개변수):
         # self -> 메서드를 호출한 객체가 자동으로 전달되는 매개변수
        self.속성 = 값  # 인스턴스 변수

# 인스턴스 생성 형식
인스턴스이름 = 클래스이름()  # 인스턴스(객체) 생성 -> 붕어빵 굽는 행위

# 메서드 호출 형식
인스턴스이름.메서드이름()  # 메서드 (함수) 호출

# 클래스 정의 형식
class Car:  # 클래스 이름은 주로 대문자로 시작
    def set_model(self, model):
        """
        자동차 모델을 설정하는 메서드
        :param model: 설정할 자동차 모델
        """
        self.model = model  # 인스턴스 변수 설정

# 인스턴스 생성 형식
my_car = Car()  # 자동차 객체 생성 -> 붕어빵 굽는 행위

# 메서드 호출 형식
my_car.set_model("Samsung")  # 자동차 모델 설정 메서드 호출

클래스 내부에는 클래스 멤버와 인스턴스 멤버를 정의할 수 있습니다.

• 클래스 멤버: 클래스 내부에서 정의된 변수로, 모든 인스턴스에서 공유됩니다.
• 인스턴스 멤버: 각 인스턴스마다 고유한 값을 가지는 변수로, 주로 생성자를 통해 초기화됩니다.

class MyClass:
    class_variable = 0  # 클래스 멤버

    def __init__(self, instance_variable):
        self.instance_variable = instance_variable  # 인스턴스 멤버

# 클래스 멤버에 접근
print("클래스 멤버에 접근:")
print("MyClass.class_variable:", MyClass.class_variable)

# 인스턴스 생성 및 인스턴스 멤버에 접근
print("\n인스턴스 생성 및 인스턴스 멤버에 접근:")
obj1 = MyClass(1)
obj2 = MyClass(2)
print("obj1.instance_variable:", obj1.instance_variable)
print("obj2.instance_variable:", obj2.instance_variable)

# 클래스 멤버 변경
print("\n클래스 멤버 변경:")
MyClass.class_variable = 10
print("MyClass.class_variable:", MyClass.class_variable)
print("obj1.class_variable:", obj1.class_variable)  # 인스턴스에서도 클래스 멤버에 접근 가능
print("obj2.class_variable:", obj2.class_variable)

# 인스턴스 멤버 변경
print("\n인스턴스 멤버 변경:")
obj1.instance_variable = 100
print("obj1.instance_variable:", obj1.instance_variable)
print("obj2.instance_variable:", obj2.instance_variable)

class Car:  # 클래스 정의
    count = 0  # 클래스 변수 정의

    def __init__(self, name, speed):  # 생성자
        self.name = name  # 인스턴스 변수
        self.speed = speed  # 인스턴스 변수
        Car.count += 1  # 클래스 변수를 1 증가시킴

    def info(self):  # 인스턴스 메서드 정의
        """
        자동차의 정보와 현재 생산된 자동차 수를 출력하는 메서드
        """
        print(f'{self.name}의 현재 속도 : {self.speed}km')
        print(f'생산된 자동차 수 : {Car.count}대')
        print('--------------------------------')

car1 = Car('붕붕카', 0)  # 인스턴스(객체) 생성(생성자도 호출)
car1.info()  # 인스턴스 메서드 호출

생성자(constructor)는 객체가 생성될 때 자동으로 호출되어 초기화 작업을 수행하는 메서드입니다. 객체에서 초깃값을 설정해야 할 필요가 있을 때 주로 사용됩니다. 파이썬에서는 생성자로 __init__ 메서드를 사용하며, 이는 스케셜 메서드(매직 메서드)로 앞뒤로 두 개의 밑줄이 붙습니다. 생성자를 사용하지 않은 예제와 사용한 예제를 비교해 생성자에 대해 자세히 살펴보겠습니다. 먼저 생성자를 사용하지 않은 예제를 확인해 보겠습니다.

class Candy:
    def set_info(self, shape, color):  # 인스턴스 메서드 정의
        self.shape = shape  # 인스턴스 변수
        self.color = color

    def print_info(self):  # 인스턴스 메서드 정의
        print(self.shape)
        print(self.color)

satang = Candy()  # 인스턴스(객체) 생성
satang.set_info('circle', 'brown')  # 인스턴스 메서드 호출
satang.print_info()  # 인스턴스 메서드 호출

class Candy2:
    def __init__(self, shape, color):  # 생성자
        self.shape = shape
        self.color = color

    def print_info(self):
        print(self.shape)
        print(self.color)

satang2 = Candy2('circle', 'red')  # 객체 생성과 동시에 생성자를 호출
satang2.print_info()  # 인스턴스 메서드 호출

satang3 = Candy2('oval', 'pink')
satang3.print_info()

생성자를 사용하면 객체가 생성될 때 초기값을 설정할 수 있어서 코드의 가독성을 높이고, 객체 생성 과정을 단순화할 수 있습니다.

---

4.클래스 메서드와 인스턴스 메서드🍰

클래스 메서드(Class Method)와 인스턴스 메서드(Instance Method)는 파이썬에서 객체 지향 프로그래밍을 할 때 중요한 역할을 하는 두 가지 종류의 메서드입니다.

• 클래스 메서드
  • 클래스 메서드는 클래스에 속한 메서드로, 클래스 또는 인스턴스를 통해 호출될 수 있습니다.
  • @classmethod 데코레이터를 통해 표시됩니다.
  • 첫 번째 매개변수로 cls를 사용하며, 클래스 자체를 가리킵니다.
  • 클래스 메서드는 클래스 변수를 사용하거나 클래스 수준의 작업을 수행할 때 주로 활용됩니다.
• 인스턴스 메서드
  • 인스턴스 메서드는 특정 인스턴스에 속한 메서드로, 해당 인스턴스를 통해 호출됩니다.
  • 일반적으로 객체의 상태를 조작하거나 객체 수준의 작업을 수행할 때 사용됩니다.
  • 메서드의 첫 번째 매개변수로 self를 사용하며, 해당 메서드를 호출한 인스턴스를 가리킵니다.

예를 들어, 자동차 클래스에서 start() 메서드가 있을 경우:

• 클래스 메서드로 정의된 경우, 모든 자동차의 시동을 걸거나 끌 때 사용할 수 있습니다.
• 인스턴스 메서드로 정의된 경우, 특정 자동차의 시동을 걸거나 끌 때 사용됩니다.

class Car:
    # 클래스 변수
    car_count = 0

    def __init__(self, brand, model):
        # 인스턴스 변수
        self.brand = brand
        self.model = model
        Car.car_count += 1

    @classmethod
    def start_all(cls):
        """
        모든 자동차의 시동을 걸 때 사용되는 클래스 메서드
        """
        print("시동을 걸었습니다.")
        # 여기에서 모든 자동차의 시동을 건다고 가정하고 동작을 작성한다.

    def start(self):
        """
        특정 자동차의 시동을 걸 때 사용되는 인스턴스 메서드
        """
        print(f"{self.brand} {self.model}의 시동을 걸었습니다.")
        # 여기에서 특정 자동차의 시동을 건다고 가정하고 동작을 작성한다.

# 클래스 메서드 호출
Car.start_all()

# 인스턴스 생성
car1 = Car("현대", "소나타")
car2 = Car("기아", "K5")

# 인스턴스 메서드 호출
car1.start()
car2.start()

클래스 메서드와 인스턴스 메서드는 각각의 용도에 맞게 적절히 사용되어야 합니다. 클래스 메서드는 클래스 전반적인 작업에 사용되고, 인스턴스 메서드는 인스턴스별로 다른 작업에 사용됩니다.

---

5.상속👪

상속은 객체 지향 프로그래밍의 중요한 개념으로, 상속을 사용하면 기존 클래스의 모든 속성과 메서드를 새로운 클래스에서 재사용할 수 있습니다. 이는 코드의 중복을 줄이고, 코드를 더 간결하고 유연하게 만들어줍니다. 또한, 상속을 통해 클래스 간의 관계를 명확히 하여 코드의 이해와 유지보수를 쉽게 만들어줍니다.
파이썬에서는 클래스 정의 시 괄호 안에 상속받을 클래스의 이름을 넣어서 상속을 구현합니다. 예를 들어 class SubClass(SuperClass): 와 같이 작성하여 SubClass가 SuperClass를 상속받도록 합니다.

class SuperClass:
    # 부모 클래스의 속성과 메서드 정의
    pass

class SubClass(SuperClass):
    # SubClass의 고유한 속성과 메서드 정의
    pass

상속을 이용한 예제를 통해 살펴보겠습니다.

class Person:  # 슈퍼 클래스(부모 클래스)
    def __init__(self, name):  # 생성자
        """
        Person 클래스의 생성자입니다.
        :param name: 이름
        """
        self.name = name

    def eat(self, food):  # 인스턴스 메서드 정의
        """
        음식을 먹는 메서드입니다.
        :param food: 먹을 음식
        """
        print(f'{self.name}가 {food}를 먹습니다.')

class Student(Person):  # 서브 클래스(자식 클래스)
    def __init__(self, name, school):  # 생성자
        """
        Student 클래스의 생성자입니다.
        :param name: 이름
        :param school: 학교
        """
        super().__init__(name)  # 슈퍼(부모) 클래스의 생성자를 호출
        self.school = school

    def study(self):  # 인스턴스 메서드 정의
        """
        공부하는 메서드입니다.
        """
        print(f'{self.name}는 {self.school}에서 공부를 합니다.')

potter = Student('해리포터', '호그와트')
potter.eat('젤리')  # 상속받은 메서드 호출
potter.study()  # 인스턴스 메서드 호출

class Coffee:  # 슈퍼 클래스(부모 클래스)
    def __init__(self, bean):  # 생성자
        """
        Coffee 클래스의 생성자입니다.
        :param bean: 원두
        """
        self.bean = bean

    def coffee_info(self):  # 인스턴스 메서드 정의
        """
        커피 정보를 출력하는 메서드입니다.
        """
        print('원두: {}'.format(self.bean))

class Espresso(Coffee):  # 서브 클래스(자식 클래스)
    def __init__(self, bean, water):  # 생성자
        """
        Espresso 클래스의 생성자입니다.
        :param bean: 원두
        :param water: 물의 양
        """
        super().__init__(bean)  # 부모의 생성자를 호출
        self.water = water

    def espresso_info(self):  # 인스턴스 메서드 정의
        """
        에스프레소 정보를 출력하는 메서드입니다.
        """
        super().coffee_info()  # 부모 클래스의 메서드를 호출
        print('물: {}ml'.format(self.water))

coffee = Espresso('콜롬비아', 30)  # 인스턴스(객체) 생성
coffee.espresso_info()  # 인스턴스 메서드 호출

coffee2 = Espresso('예가체프', 50)
coffee2.espresso_info()

상속은 기존 클래스의 속성과 메서드를 새로운 클래스에서 재사용할 수 있는 강력한 도구입니다. 그러나 다중 상속을 사용할 때에는 주의해야 합니다. 다중 상속은 한 클래스가 여러 개의 부모 클래스로부터 상속을 받는 것을 의미합니다. 파이썬은 다중 상속을 지원하지만, 이에는 몇 가지 주의할 점이 있습니다.
다중 상속을 사용하면 코드의 복잡성이 증가할 수 있고, 클래스 간의 의존성이 높아져서 코드를 이해하기 어려워질 수 있습니다. 또한, 다이아몬드 상속과 같은 특정 상황에서는 메서드 충돌이 발생할 수 있습니다. 이러한 이유로 다중 상속을 사용할 때에는 신중하게 고려해야 합니다. 가능한 경우 단일 상속을 사용하고, 필요한 경우에만 다중 상속을 사용하는 것이 좋습니다.

🙌 여기서 잠깐

다이아몬드 상속이란?
다이아몬드 상속은 다중 상속 구조에서 특정 클래스가 두 개 이상의 상위 클래스로부터 상속을 받을 때 발생하는 문제를 말합니다. 이는 다음과 같은 상속 구조에서 발생합니다.

    A
   / \
  B   C
   \ /
    D

여기서 클래스 D가 클래스 B와 클래스 C로부터 상속을 받고, 클래스 B와 클래스 C는 모두 클래스 A로부터 상속을 받는 경우를 고려해 봅시다. 이런 구조에서 클래스 D는 클래스 A의 속성과 메서드를 중복으로 상속받게 됩니다. 이로 인해 메서드 충돌이 발생할 수 있고, 클래스 간의 의존성이 높아져서 코드를 이해하기 어려워질 수 있습니다.

다이아몬드 상속은 그 모양이 다이아몬드와 유사하여 이렇게 불리며, 이러한 상속 구조를 만나면 메서드 충돌 등의 문제를 해결하기 위해 적절한 방법으로 다중 상속을 사용해야 합니다.

---

6.핵심 내용👀