---

layout: single

title: Unit36 클래스 상속 사용하기

클래스 상속 사용하기

클래스 상속(inheritance)

• 기반 클래스는
  • 부모 클래스(parent class)
  • 슈퍼 클래스(superclass)
• 파생 클래스는
  • 자식 클래스(child class)
  • 서브 클래스(subclass)

기반 클래스의 능력을 그대로 활용하면서 새로운 클래스를 만들 때 사용
동물을 예로 들면 척추동물에서 포유류, 조류, 파충류 등을 만드는 식
기반클래스 = 척추동물
파생클래스 = 포유류, 조류

사람 클래스로 학생 클래스 만들기

class 기반클래스이름:
    코드
 
class 파생클래스이름(기반클래스이름):
    코드

#사람(원조)중에 학생(상속자)이 있는 것
class Person:
    def greeting(self):
        print('안녕하세요.')
 
class Student(Person):
    def study(self):
        print('공부하기')
 
james = Student()
james.greeting()    # 안녕하세요.: 기반 클래스 Person의 메서드 호출
james.study()       # 공부하기: 파생 클래스 Student에 추가한 study 메서드.

안녕하세요.
공부하기

클래스 상속은 기반 클래스의 기능을 유지하면서 새로운 기능을 추가

# 상속관계 확인
class Person:
    pass
class Student(Person):
    pass

issubclass(Student, Person)

True

# Student가 Person의 파생 클래스이므로 issubclass는 True

상속 관계와 포함 관계 알아보기

어디에 사용해야 할까?

상속 관계 ( is-a 관계 : Student is a Person)

class Person:
    def greeting(self):
        print('안녕하세요.')
 
class Student(Person):
    def study(self):
        print('공부하기')

포함관계 (has-a 관계 : PersonList has a Person)

class Person:
    def greeting(self):
        print('안녕하세요.')
 
class PersonList:
    def __init__(self):
        self.person_list = []    # 리스트 속성에 Person 인스턴스를 넣어서 관리
 
    def append_person(self, person):    # 리스트 속성에 Person 인스턴스를 추가하는 함수
        self.person_list.append(person)

# 상속을 사용하지 않고 속성에 인스턴스를 넣어서 관리하므로 PersonList가 Person을 포함

기반 클래스의 속성 사용하기

기반클래스에 들어있는 인스턴스 속성 사용

• Peraon 클래스에 hello 속성
• Peraon 클래스의 상속을 받아 Student 클래스를 생성
• Student로 인스턴스를 만들고 hello 속성에 접근

class Person:
    def __init__(self):
        print('Person __init__')
        self.hello = '안녕하세요.'
 
class Student(Person):
    def __init__(self):
        print('Student __init__')
        self.school = '파이썬 코딩 도장'
 
james = Student()
print(james.school)
print(james.hello)    # 기반 클래스의 속성을 출력하려고 하면 에러가 발생함

Student __init__
파이썬 코딩 도장



---------------------------------------------------------------------------

AttributeError                            Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_17577/684535431.py in <module>
     11 james = Student()
     12 print(james.school)
---> 13 print(james.hello)    # 기반 클래스의 속성을 출력하려고 하면 에러가 발생함


AttributeError: 'Student' object has no attribute 'hello'

super()로 기반 클래스 초기화하기

super()를 사용하여 기반 클래스의 int 메서드를 호출

• super().메서드()

class Person:
    def __init__(self):
        print('Person __init__')
        self.hello = '안녕하세요.'
 
class Student(Person):
    def __init__(self):
        print('Student __init__')
        super().__init__()                # super()로 기반 클래스의 __init__ 메서드 호출
        self.school = '파이썬 코딩 도장'
 
james = Student()
print(james.school)
print(james.hello)

Student __init__
Person __init__
파이썬 코딩 도장
안녕하세요.

기반 클래스의 속성을 찾는 과정

기반 클래스를 초기화하지 않아도 되는 경우

파생 클래스에서 init 메서드를 생략한다면
기반 클래스의 init이 자동으로 호출되므로
super()는 사용하지 않아도 됩

class Person:
    def __init__(self):
        print('Person __init__')
        self.hello = '안녕하세요.'
 
class Student(Person):
    pass
 
james = Student()
print(james.hello)

Person __init__
안녕하세요.

메서드 오버라이딩 사용하기

파생 클래스에서 기반 클래스의 메서드를 새로 정의하는 메서드 오버라이딩

# Person의 greeting 메서드가 있는 상태에서 Student에도 greeting 메서드를 만듭
class Person:
    def greeting(self):
        print('안녕하세요.')
 
class Student(Person):
    def greeting(self):
        print('안녕하세요. 저는 파이썬 코딩 도장 학생입니다.')
 
james = Student()
james.greeting()

안녕하세요. 저는 파이썬 코딩 도장 학생입니다.

오버라이딩 사용 이유

• 프로그램에서 어떤 기능이 같은 메서드 이름으로 계속 사용되어야 할 때

class Person:
    def greeting(self):
        print('안녕하세요.')
 
class Student(Person):
    def greeting(self):
        super().greeting()    # 기반 클래스의 메서드 호출하여 중복을 줄임
        print('저는 파이썬 코딩 도장 학생입니다.')
 
james = Student()
james.greeting()

안녕하세요.
저는 파이썬 코딩 도장 학생입니다.

다중 상속 사용하기

class 기반클래스이름1:
    코드
 
class 기반클래스이름2:
    코드
 
class 파생클래스이름(기반클래스이름1, 기반클래스이름2):
    코드

class Person:
    def greeting(self):
        print('안녕하세요.')
 
class University:
    def manage_credit(self):
        print('학점 관리')     # 기반 클래스 Person과 University
 
class Undergraduate(Person, University):
    def study(self):
        print('공부하기')   
                # 파생 클래스 Undergraduate를 만들 때 
                # class Undergraduate(Person, University):와 
                # 같이 괄호 안에 Person과 University를 
                # 콤마로 구분해서 넣음 
                # 이렇게 하면 두 기반 클래스의 기능을 모두 상속

james = Undergraduate()
james.greeting()         # 안녕하세요. : 기반 클래스 Person의 메서드 호출
james.manage_credit()    # 학점 관리  : 기반 클래스 University의 메서드 호출
james.study()            # 공부하기   : 파생 클래스 Undergraduate에 추가한 study 메서드

안녕하세요.
학점 관리
공부하기

# 다음과 같이 Undergraduate 클래스의 인스턴스로 
# Person의 greeting과 University의 manage_credit을 호출할 수 있음

james = Undergraduate()
james.greeting()         # 안녕하세요. : 기반 클래스 Person의 메서드 호출
james.manage_credit()    # 학점 관리  : 기반 클래스 University의 메서드 호출
james.study()            # 공부하기   : 파생 클래스 Undergraduate에 추가한 study 메서드

안녕하세요.
학점 관리
공부하기

Person, University, Undergraduate 클래스의 관계

다이아몬드 상속

class A:
    def greeting(self):
        print('안녕하세요. A입니다.')
 
class B(A):
    def greeting(self):
        print('안녕하세요. B입니다.')
 
class C(A):
    def greeting(self):
        print('안녕하세요. C입니다.')
 
class D(B, C):
    pass
 
x = D()
x.greeting()    # 안녕하세요. B입니다.

안녕하세요. B입니다.

메소드 탐색 순서 확인

• 메서드 탐색 순서(Method Resolution Order, MRO)를 따름
• 클래스 D에 메서드 mro를 사용해보면 메서드 탐색 순서가 나옴.

D.mro()

[__main__.D, __main__.B, __main__.C, __main__.A, object]

D의 메서드 호출 순서는

• 자기 자신 D,
• 그 다음이 B입니다. 따라서 D로 인스턴스를 만들고 greeting을 호출하면 B의 greeting이 호출

x = D()
x.greeting()    # 안녕하세요. B입니다.

안녕하세요. B입니다.

파이썬은 다중 상속을 한다면 class D(B, C):의 클래스 목록 중 왼쪽에서 오른쪽 순서로 메서드를 찾습니다. 그러므로 같은 메서드가 있다면 B가 우선합니다. 만약 상속 관계가 복잡하게 얽혀 있다면 MRO를 살펴보는 것이 편리

추상 클래스 사용하기

추상 클래스(abstract class)라는 기능을 제공

• 메서드의 목록만 가진 클래스이며 상속받는 클래스에서 메서드 구현을 강제하기 위해 사용
• 추상 클래스를 만들려면 import로 abc 모듈을 가져와야 합니다( abc는 abstract base class의 약자)
• 클래스의 ( )(괄호) 안에 metaclass=ABCMeta를 지정
• 메서드를 만들 때 위에 @abstractmethod를 붙여서 추상 메서드로 지정

from abc import *
 
class 추상클래스이름(metaclass=ABCMeta):
    @abstractmethod
    def 메서드이름(self):
        코드

• from abc import *로 abc 모듈의 모든 클래스와 메서드 가져옴.
• 만약 import abc로 모듈을 가져왔다면 abc.ABCMeta, @abc.abstractmethod로 사용

# 학생 추상 클래스 StudentBase를 만들고, 이 추상 클래스를 상속받아 학생 클래스 Student
from abc import *
 
class StudentBase(metaclass=ABCMeta):
    @abstractmethod
    def study(self):
        pass
 
    @abstractmethod
    def go_to_school(self):
        pass
 
class Student(StudentBase):
    def study(self):
        print('공부하기')
 
james = Student()
james.study()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_17577/186541337.py in <module>
     15         print('공부하기')
     16 
---> 17 james = Student()
     18 james.study()


TypeError: Can't instantiate abstract class Student with abstract methods go_to_school

추상 클래스 StudentBase에서는 추상 메서드로 study와 go_to_school을 정의했습니다. 하지만 StudentBase를 상속받은 Student에서는 study 메서드만 구현하고, go_to_school 메서드는 구현하지 않았으므로 에러가 발생

from abc import *
 
class StudentBase(metaclass=ABCMeta):
    @abstractmethod
    def study(self):
        pass
 
    @abstractmethod
    def go_to_school(self):
        pass
 
class Student(StudentBase):
    def study(self):
        print('공부하기')
 
    def go_to_school(self):
        print('학교가기')
 
james = Student()
james.study()
james.go_to_school()

공부하기
학교가기

추상 메서드를 빈 메서드로 만드는 이유

• 추상 클래스는 인스턴스로 만들 수가 없다는 점
• 추상 클래스 StudentBase로 인스턴스를 만들면 에러가 발생

james = StudentBase()

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

/var/folders/nv/7gm32z8n6cz1dzxgymhz5lmh0000gn/T/ipykernel_17577/1043146601.py in <module>
----> 1 james = StudentBase()


TypeError: Can't instantiate abstract class StudentBase with abstract methods go_to_school, study

지금까지 추상 메서드를 만들 때 pass만 넣어서 빈 메서드로 만든 것입니다. 왜냐하면 추상 클래스는 인스턴스를 만들 수 없으니 추상 메서드도 호출할 일이 없기 때문

    @abstractmethod
    def study(self):
        pass    # 추상 메서드는 호출할 일이 없으므로 빈 메서드로 만듦
 
    @abstractmethod
    def go_to_school(self):
        pass    # 추상 메서드는 호출할 일이 없으므로 빈 메서드로 만듦

추상 클래스는 인스턴스로 만들 때는 사용하지 않으며 오로지 상속에만 사용합니다.
그리고 파생 클래스에서 반드시 구현해야 할 메서드를 정해 줄 때 사용

문제풀기

퀴즈

연습문제: 리스트에 기능 추가하기

심사문제: 다중 상속 사용하기

총정리

클래스(Class)란 무엇인가

• 자료형을 위한 일종의 템플릿
• 참고
  • 자료형 (type)

print(type("string"))
print(type(1))

<class 'str'>
<class 'int'>

class TestClass:
  pass

인스턴스 (Instantiation)

• 클래스를 정의하고 나면 그걸 불러와서 사용하는 법
• 클래스를 이용해 인스턴스(instance)를 만들어주면 됨
• 임시로 어떤 템플릿을 불러와서 그걸 다른 이름의 객체로 저장

test_instance = TestClass()

• 클래스 이름에 괄호를 추가하여 인스턴스를 만들고, 그걸 변수 @@@_instance에 할당
• 수많은 인스턴스를 호출하는 것도 가능

test_instance1 = TestClass()
test_instance2 = TestClass()
test_instance3 = TestClass()

객체 지향 프로그래밍 (Object-Oriented Programming)

• 클래스, 인스턴스는 객체(object)
• 클래스를 정의하고 객체를 만드는 패턴을 객체 지향 프로그래밍(OOP)
• 인스턴스를 불러온다는 건 클래스를 가져와 객체로 바꿔준다는 것
• type() 함수를 사용하는 건 그 반대
  • 객체의 type을 확인해보면 해당 객체가 어떤 클래스의 인스턴스인지를 확인

print(type(test_instance))
# <class '__main__.TestClass'>

<class '__main__.TestClass'>

• main은 “현재 실행 중인 파일”을 의미

클래스 변수 (Class Variables)

• 클래스를 정의할 때 그 안에서 변수를 정의하면 모든 인스턴스에서 동일한 데이터를 사용
• 정의된 클래스 변수는 object.variable 구문을 사용하여 액세스

class Musician:
  title = "Rockstar"

각각 다른 인스턴스를 호출해도 각 인스턴스 안에 있는 title 변수는 똑같음

drummer = Musician()
guitarist = Musician()
print(drummer.title)
print(guitarist .title)

Rockstar
Rockstar

메서드 (Methods)

• 메서드는 클래스 안에서 정의된 함수
• 메서드를 정의할 때는 첫 번째 인수를 항상 self로 지정해야 한다

class Musician:
    title = "Rockstar"
    def explanation(self):
        print("I am a {}!".format(self.title))
drummer = Musician()
drummer.explanation()
#I am a Rockstar!

I am a Rockstar!

• 함수 안에서 클래스 변수를 사용할 때는 self.title과 같은 형식으로 불러옴

class Circle():
    pi = 3.14
  
    def area(self, radius):
        return self.pi * radius ** 2
  
circle = Circle()

pizza_area = circle.area(6)
table_area = circle.area(18)

생성자 (Constructor)

• 클래스를 호출할 때 자동으로 어떤 함수를 실행하거나 값을 호출하고 싶다면 생성자(Constructor)라는 걸 정의
• 메서드 정의할 때와 똑같긴 한데 메서드 이름으로 init을 사용

class Shouter:
    def __init__(self):
        print("HELLO?!")
shout = Shouter()

HELLO?!

• Shouter라는 클래스를 객체로 불러올 때마다 해당 문자열이 즉시 출력

class Circle:
    pi = 3.14
    def __init__(self, radius):
        print("New circle with radius: {}".format(radius))
table = Circle(18)

New circle with radius: 18

Circle이라는 클래스의 생성자 init을 잘 살펴보면 self 말고도 radius라는 인수를 받는다. 그래서 객체를 생성할 때 괄호 안에 인수를 넣어주어야 함

인스턴스 변수 (Instance Variables)

• 객체를 구별해서 인스턴스를 생성하는 이유는 각 인스턴스가 다른 종류의 데이터, 즉 인스턴스 변수를 보유할 수 있기 때문
• 각 객체가 보유한 데이터인 인스턴스 변수는 해당 클래스의 모든 인스턴스가 공유하는 게 아님

# 일단 클래스 정의 두개의 인스턴스 불러오기
class FakeDict:
    pass
fake_dict1 = FakeDict()
fake_dict2 = FakeDict()

# 각 객체에 fake_key라는 인스턴스 변수로 각각 다른 값을 넣어주면
fake_dict1.fake_key = "This works!"
fake_dict2.fake_key = "This too!"

# 별도로 사용이 가능
working_string = "{} {}".format(fake_dict1.fake_key, fake_dict2.fake_key)
print(working_string)

This works! This too!

인스턴스 변수의 활용, self

• 인스턴스를 생성할 때 작동하는 생성자(constructor)를 활용해서 인스턴스 변수를 생성하고 관리하면 너무나 편리하기 때문임
• 인스턴스를 만들 때 애초에 이름을 넣어주었기 때문에 각 인스턴스의 name에서 그 이름을 그대로 가지고 있게 됨
• 활용해서 메서드를 작성
• 클래스 변수와 인스턴스 변수를 모두 자유롭게 사용할 수 있게 됨

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

mail_to_park = AutoEmail("PARK")
mail_to_kim = AutoEmail("KIM")

print(mail_to_park.name)
# "PARK"

print(mail_to_kim.name)
# "KIM"

PARK
KIM

인스턴스를 만들 때 이름을 넣어주었기 때문에 각 인스턴스의 name에서 그 이름을 그대로 가지고 있게 됨

class AutoEmail:
    intro = "안녕하세요"

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

    def say_hello(self):
        return "{intro} {name} 님".format(intro=self.intro, name=self.name)

mail_to_park = AutoEmail("PARK")
mail_to_kim = AutoEmail("KIM")

print(mail_to_park.say_hello())
# "안녕하세요 PARK 님"

print(mail_to_kim.say_hello())
# "안녕하세요 KIM 님"

클래스 변수와 인스턴스 변수 모두 자유롭게 사용 가능