[Python / 기초] 파이썬 클래스(OOP) - 생성자, 소멸자, 인스턴스, 변수, 메소드, 상속

📍 객체지향 프로그래밍(OOP)

• 클래스(class) : 같은 종류의 집단에 속하는 속성(attribute)과 행위(method)를 정의한 것
• 인스턴스(instance) : 클래스를 실제로 메모리상에 할당한 것
• 속성(attribute) : 클래스/인스턴스가 가지고 있는 데이터/값
• 행위(method) : 클래스/인스턴스가 가지고 있는 함수/기능

# 클래스 : 허수는 (실수 + 허수)로 구성하기로 정의
# 인스턴스 : number로 할당
number = 1 + 1j

# number가 가지고 있는 속성 : .real / .image
print(number.real) # 1.0
print(number.imag) # 1.0

# my_list에 적용할 수 있는 행위 : .reverse()
my_list = [1, 2, 3, 4]
my_list.reverse()
print(my_list) # [4, 3, 2, 1]

 

📍 Class

 

✅ class 선언

class ClassName:
    attribute = value

    def method_name(self):
        code

✔️ 예시

class MyClass:
    name = 'han'

    def hello(self):
        return 'hello'

 

✅ 인스턴스화

ClassName()

✔️ 예시

a = MyClass()
print(a.name) # han
print(a.hello()) # hello

b = MyClass()
b.name = 'kim'
print(b.name) # kim
print(b.hello()) # hello

 

 

✔️ 응용

class Phone:
    power = False
    number = '010-0000-0000'
    book = {}
    model = ''

    def on(self):
        if self.power == False:
            self.power = True

    def off(self):
        if self.power == True:
            self.power = False

    def call(self, target):
        if self.power == True:
            print(f'제 번호는 {self.number}입니다.')
            print(f'{target}로 전화 거는 중')

        else:
            print('휴대폰을 켜주세요.')

my_phone = Phone()
my_phone.number = '010-1234-1234'
my_phone.on()
print(my_phone.power) # True
my_phone.call('112') # 제 번호는 010-1234-1234입니다.
		     # 112로 전화 거는 중


your_phone = Phone()
print(your_phone.power) # False
your_phone.call('119') # 휴대폰을 켜주세요.

 

 

✅ 생성자, 소멸자

class MyClass:
    # 생성자
    def __init__(self):
        pass

    # 소멸자
    def __del__(self):
        pass

✔️ 예시 1

class Person:
    name = 'noname'

    def __init__(self, name='익명'):
        self.name = name
        print('생성됨')

    def __del__(self):
        print('소멸됨')

# p1이 생성됨에 따라 Person.__init__이 자동실행(따라서 name을 입력)
# '생성됨'이 p1 생성과 동시에 프린트
p1 = Person('han')
print(p1.name) # 생성됨
	       # han

# Person 기본값
print(Person.name) # noname

# p1 인스턴스에 .phone이라는 속성을 추가
# p1 인스턴스는 단일객체이기 때문에 Person class에 phone 속성이 없어도 추가 가능
p1.phone = '010-1234-1234'
print(p1.phone) # 010-1234-1234

del p1 # 소멸됨

# p1은 소멸되었기 때문에 error
print(p1)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[12], line 1
----> 1 print(p1)

NameError: name 'p1' is not defined

# 2번 실행할 경우
# p1에 있던 데이터가 소멸된 후 다시 데이터를 저장
# 따라서 생성됨, 소멸됨이 모두 프린트됨
p1 = Person('han') # 생성됨
p1 = Person('han') # 생성됨
		   # 소멸됨
print(p1.name) # han

✔️ 예시 2

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

    def info(self):
        return (self.x, self.y)

# Circle
class Circle:
    def __init__(self, point, r):
        self.point = point
        self.r = r

    def info(self):
        return (self.point.x, self.point.y, self.r)

    def move(self, x, y):
        self.point.x = x
        self.point.y = y

p1 = Point(3, 3) # 소멸됨
print(p1.info()) # (3, 3)

c1 = Circle(p1, 10)
print(c1.point) # <__main__.Point object at 0x106840e50>

print(c1.point.info()) # (3, 3) Point의 info
print(c1.info()) # (3, 3, 10) Circle의 info

 

 

✅ 클래스 변수

• 클래스 선언 블록 최상단에 위치

 

✅ 인스턴스 변수

• 인스턴스 내부에서 생성한 변수('self.variable = ')

class MyClass:
    class_variable = '클래스변수'

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

✔️ 예시

class Person:
    name = '홍길동'
    phone = '010-1234-1234'

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

p1 = Person('한희주')
print(p1.name) # 한희주 인스턴스변수
print(Person.name) # 홍길동 클래스변수

print(p1.phone) # 010-1234-1234

 

 

✅ 클래스 메소드, 인스턴스 메소드, 스태틱 메소드

• 클래스 메소드 : self가 아닌 cls 파라미터 사용
  클래스 자체에서 직접 호출
• 인스턴스 메소드 : self 파라미터 사용
• 스태틱 메소드 : self 파라미터 X, 객체와 독립적
  인스턴스 변수에 접근 불가

class MyClass:
  def instance_method(self):
      pass

  @classmethod
  def class_method(cls):
      pass

  @staticmethod
  def static_method():
      pass

✔️ 예시

class Puppy:
    num_of_puppy = 0

    def __init__ (self, name):
        self.name = name
        Puppy.num_of_puppy += 1

    @classmethod
    def get_status(cls):
        print(f'현재 강아지는 {cls.num_of_puppy}마리입니다.')

    @staticmethod
    def bark(msg):
        return msg

    def bark2(self, msg):
        return f'{self.name}은 {msg}합니다.'

p1 = Puppy('백구')
p2 = Puppy('재롱')

print(Puppy.num_of_puppy) # 2

Puppy.get_status() # 현재 강아지는 2마리입니다.

print(p1.bark('멍멍')) # 멍멍
print(p2.bark('그르릉')) # 그르릉

print(p1.bark2('멍멍')) # 백구은 멍멍합니다.

 

 

✅ 상속

✔️ 상속 전

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

    def greeting(self):
        print(f'안녕하세요. {self.name}입니다.')

p1 = Person('홍길동')
p1.greeting() # 안녕하세요. 홍길동입니다.

class Student:
    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id

    def greeting(self):
        print(f'안녕하세요. {self.name}입니다.')

s1 = Student('한희주', '123123')
s1.greeting() # 안녕하세요. 한희주입니다.

 

 

✔️ 상속 후

# 아래 주석과 같이 Person정보를 Student에 모두 들고 옴
class Student(Person):
    # def __init__(self, name):
    #     self.name = name

    # def greeting(self):
    #     print(f'안녕하세요. {self.name}입니다.')

    def __init__(self, name, student_id):
        self.name = name
        self.student_id = student_id

s1 = Student('한희주', '123123')
s1.greeting() # 안녕하세요. 한희주입니다.

 

 

✅ 다중상속

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

    def breath(self):
        print('후하')

# Person 상속
class Mom(Person):
    gene = 'xx'

    def swim(self):
        print('어푸어푸')
        
# Person 상속
class Dad(Person):
    gene = 'xy'

    def run(self):
        print('다다다')
        
# Dad, Mom 상속
class Baby(Dad, Mom):
    pass

b = Baby('금쪽이')
print(b.name) # 금쪽이
print(b.gene) # xy 상위 클래스의 순서따라 상속받는 데이터가 다름
b.swim() # 어푸어푸
b.run() # 다다다
b.breath() # 후하