파이썬의 클래스 구조¶

class 키워드를 사용한 클래스 정의¶

In [1]:

class Page:  # 클래스 정의
    def __init__(self, num, content):
        self.num = num  # ページ番号
        self.content = content  # 페이지 내용
    def output(self):
        return f'{self.content}'

In [2]:

Page  # 클래스 객체 Page가 정의됨

Out[2]:

__main__.Page

인스턴스 만들기¶

In [3]:

# 인스턴스화
title_page = Page(0, 'Python Practice Book')

In [4]:

type(title_page)  # 인스턴스의 클래스를 확인함

Out[4]:

__main__.Page

In [5]:

# Page 클래스의 인스턴스인지 확인함
isinstance(title_page, Page)

Out[5]:

True

In [6]:

# 인스턴스가 가진 속성을 확인함
dir(title_page)

Out[6]:

['__class__',
 '__delattr__',
 '__dict__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__le__',
 '__lt__',
 '__module__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 '__weakref__',
 'content',
 'num',
 'output']

인스턴스 ── 클래스를 기반으로 만들어진 객체¶

인스턴스 메서드 ── 인스턴스에 묶인 메서드¶

In [7]:

title_page.output()  # 인스턴스 메서드 호출

Out[7]:

'Python Practice Book'

메서드 객채와 함수 객체¶

In [8]:

class Klass:
    def some_method(self):  # 인스턴스 메서드 정의
        print('method')

In [9]:

def some_function(self):  # 같은 인수의 함수 정의
    print('function')

In [10]:

# 함수는 function 클래스의 인스턴스임
type(some_function)

Out[10]:

function

In [11]:

# 인스턴스 메서드도 function 클래스의 인스턴스
type(Klass.some_method)

Out[11]:

function

In [12]:

# 인스턴스를 통해 접근하면 method 클래스가 됨
kls = Klass()
type(kls.some_method)

Out[12]:

method

In [13]:

# 클래스 객체의 속성에 함수를 추가
Klass.some_function = some_function

In [14]:

# 인스턴스 메서드로 실행
kls.some_function()

function

인스턴스 변수 ── 인스턴스가 저장하는 변수¶

In [15]:

title_page.section = 0
title_page.section

Out[15]:

In [16]:

first_page = Page(1, 'first page')
first_page.section

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-16-622c9b4a10cc> in <module>
      1 first_page = Page(1, 'first page')
----> 2 first_page.section

AttributeError: 'Page' object has no attribute 'section'

인스턴스 초기화¶

init() ── 인스턴스 초기화를 수행하는 특수 메서드¶

In [17]:

# 클래스 정의 
class Page:
    def __init__(self, num, content, section=None):
        self.num = num
        self.content = content
        self.section = section
    def output(self):
        return f'{self.content}'

인수를 전달해 인스턴스화 하기¶

In [18]:

# 인스턴스 작성
title_page = Page(0, 'Python Practice Book')

In [19]:

title_page.section  # section은 None

In [20]:

title_page.output()

Out[20]:

'Python Practice Book'

In [21]:

# section을 지정해 다른 인스턴스를 작성
first_page = Page(1, 'first page', 1)

In [22]:

first_page.section  # section이 지정되어 있음

Out[22]:

In [23]:

first_page.output()

Out[23]:

'first page'

init()과 new()의 차이 ── 이니셜라이저와 컨스트럭터¶

In [24]:

class Klass:
    def __new__(cls, *args):  # 컨스트럭터
        print(f'{cls=}')
        print('new', args)
        # 작성한 인스터스를 반환함 
        return super().__new__(cls)
    def __init__(self, *args): # 이니셜라이저
        # 인스턴스 초기화는 여기에서 수행함
        print('init', args)

In [25]:

# 인스턴스화
kls = Klass(1, 2, 3)

cls=<class '__main__.Klass'>
new (1, 2, 3)
init (1, 2, 3)

new() 사용 시 주의점¶

In [26]:

class Evil:
    def __new__(cls, *args):
        return 1

In [27]:

# Evil 클래스 인스턴스화
evil = Evil()

In [28]:

isinstance(evil, Evil)

Out[28]:

False

In [29]:

type(evil)

Out[29]:

int

In [30]:

# 인스턴스는 __new__()의 반환값
evil

Out[30]:

In [31]:

class MyClass(Evil):
    def print_class(self):
        print('MyClass')

In [32]:

my = MyClass()  # my 값은 1이 됨

In [33]:

# 추가되었어야 할 메서드를 이용할 수 없음
my.print_class()

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-33-5c63bdce6f16> in <module>
      1 # 추가되었어야 할 메서드를 이용할 수 없음
----> 2 my.print_class()

AttributeError: 'int' object has no attribute 'print_class'

In [34]:

my

Out[34]:

프로퍼티 ── 인스턴스 메서드를 인스턴스 변수와 같이 다룸¶

In [35]:

class Book:
    def __init__(self, raw_price):
        if raw_price < 0:
            raise ValueError('price must be positive')
        self.raw_price = raw_price
        self._discounts = 0
    @property
    def discounts(self):
        return self._discounts
    @discounts.setter
    def discounts(self, value):
        if value < 0 or 100 < value:
            raise ValueError(
                'discounts must be between 0 and 100')
        self._discounts = value
    @property
    def price(self):
        multi = 100 - self._discounts
        return int(self.raw_price * multi / 100)

In [36]:

book = Book(2000)
book.discounts  # 초기 할인율 0

Out[36]:

In [37]:

book.price  # 초기 가격 2000

Out[37]:

In [38]:

book.discounts = 20  # 할인율 설정
book.price  # 할인 후의 가격

Out[38]:

In [39]:

book.discounts = 120  # 할인율이 100을 초과하면 에러 발생

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-39-4bc99df62c28> in <module>
----> 1 book.discounts = 120  # 할인율이 100을 초과하면 에러 발생

<ipython-input-35-553c66fea917> in discounts(self, value)
     11     def discounts(self, value):
     12         if value < 0 or 100 < value:
---> 13             raise ValueError(
     14                 'discounts must be between 0 and 100')
     15         self._discounts = value

ValueError: discounts must be between 0 and 100

property ── 값을 얻을 때 호출되는 메서드¶

setter ── 값을 설정할 때 호출되는 메서드¶

In [40]:

book.discounts = -20

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-40-1a951ff04058> in <module>
----> 1 book.discounts = -20

<ipython-input-35-553c66fea917> in discounts(self, value)
     11     def discounts(self, value):
     12         if value < 0 or 100 < value:
---> 13             raise ValueError(
     14                 'discounts must be between 0 and 100')
     15         self._discounts = value

ValueError: discounts must be between 0 and 100

In [41]:

book.price = 1000

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-41-cd29227d939f> in <module>
----> 1 book.price = 1000

AttributeError: can't set attribute

클래스와 인스턴스의 프라이빗 속성¶

언더스코어로 시작하는 속성¶

In [42]:

book._discounts  # _로 시작하는 변수도 참조할 수 있음

Out[42]:

언더스코어 2개로 시작하는 속성¶

In [43]:

class Klass:
    def __init__(self, x):
        self.__x = x

In [44]:

kls = Klass(10)
kls.__x  # 이 이름으로는 참조할 수 없음

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-44-0c02c06d28bb> in <module>
      1 kls = Klass(10)
----> 2 kls.__x  # 이 이름으로는 참조할 수 없음

AttributeError: 'Klass' object has no attribute '__x'

In [45]:

kls._Klass__x  # 변환 규칙을 알고 있다면 참조할 수 있음

Out[45]:

프라이빗 속성에 대한 파이썬 커뮤니티의 사상¶

클래스 ── 인스턴스의 모형이 되는 객체¶

클래스 변수 ── 클래스 객체가 유지하는 변수¶

In [46]:

# 클래스 변수를 가진 클래스 정의
class Page:
    book_title = 'Python Practice Book'

In [47]:

Page.book_title  # 인스턴스가 없어도 참조할 수 있음

Out[47]:

'Python Practice Book'

In [48]:

Page.book_title = 'No title'  # 클래스 변수 업데이트
Page.book_title

Out[48]:

'No title'

클래스 변수는 인스턴스에서도 참조 가능¶

In [49]:

first_page = Page()
second_page = Page()

In [50]:

# 클래스 변수는 인스턴스에서도 참조 가능
first_page.book_title

Out[50]:

'No title'

In [51]:

second_page.book_title

Out[51]:

'No title'

In [52]:

# 클래스 변수 업데이트
Page.book_title = 'Python Practice Book'

In [53]:

# 클래스 변수는 모든 인스턴스에서 공유됨
first_page.book_title

Out[53]:

'Python Practice Book'

In [54]:

second_page.book_title

Out[54]:

'Python Practice Book'

In [55]:

# 아래는 인스턴스 변수가 됨
first_page.book_title = '[Draft]Python Practice Book'
first_page.book_title

Out[55]:

'[Draft]Python Practice Book'

In [56]:

# 클래스 변수는 변경되지 않음
Page.book_title

Out[56]:

'Python Practice Book'

In [57]:

first_page.book_title  # 인스턴스 변수

Out[57]:

'[Draft]Python Practice Book'

In [58]:

# 인스턴스 변수 삭제
del first_page.book_title

In [59]:

# 인스턴스 속성이 아니므로, 클래스 속성이 검색됨
first_page.book_title

Out[59]:

'Python Practice Book'

클래스 메서드 ── 클래스에 속한 메서드¶

In [60]:

# 속성을 이용한 정렬에 사용할 수 있는 표준 라이브러리를 임포트
from operator import attrgetter

In [61]:

class Page:
    book_title = 'Python Practice Book'
    def __init__(self, num, content):
        self.num = num
        self.content = content
    def output(self):
        return f'{self.content}'
    # 클래스 메서드의 첫 번째 인수는 클래스 객체
    @classmethod
    def print_pages(cls, *pages):
        # 클래스 객체 이용
        print(cls.book_title)
        pages = list(pages)
        # 페이지 순으로 정렬해서 출력
        for page in sorted(pages, key=attrgetter('num')):
            print(page.output())

In [62]:

first = Page(1, 'first page')
second = Page(2, 'second page')
third = Page(3, 'third page')

In [63]:

# 클래스 메서드 호출
Page.print_pages(first, third, second)

Python Practice Book
first page
second page
third page

In [64]:

# 인스턴스에서도 호출할 수 있음
first.print_pages(first, third, second)

Python Practice Book
first page
second page
third page

스태틱 메서드 ── 함수처럼 동작하는 메서드¶

In [65]:

class Page:
    def __init__(self, num, content):
        self.num = num
        self.content = content
    @staticmethod  # 스태틱 메서드로 정의
    def check_blank(page):
        return bool(page.content)

In [66]:

page = Page(1, '')
Page.check_blank(page)

Out[66]:

False

In [67]:

def check_blank(page):  # 함수로 문제 없음
    return bool(page.content)

In [68]:

check_blank(page)

Out[68]:

False

클래스 상속¶

메서드 오버라이드와 super()를 사용한 베이스 클래스로의 접근¶

In [69]:

class Page:
    def __init__(self, num, content):
        self.num = num
        self.content = content
    def output(self):
        return f'{self.content}'

In [70]:

# 메서드 오버라이드 
class TitlePage(Page):
    def output(self):
        # 베이스 클래스의 메서드는 자동으로 호출되지 않으므로
        # 명시적으로 호출함
        title = super().output()
        return title.upper()

In [71]:

title = TitlePage(0, 'Python Practice Book')
title.output()

Out[71]:

'PYTHON PRACTICE BOOK'

모든 객체는 object 클래스의 서브 클래스¶

In [72]:

class Length(float):  # 내장 타입의 서브 클래스 작성
    def to_cm(self):
        return super().__str__() + 'cm'

In [73]:

pencil_length = Length(16)
print(pencil_length.to_cm())

16.0cm

다중 상속 ── 여러 베이스 클래스를 지정¶

In [74]:

class HTMLPageMixin:
    def to_html(self):
        return f'<html><body>{self.output()}</body></html>'

In [75]:

# 다중 상속을 사용한 Mixin 이용
class WebPage(Page, HTMLPageMixin):
    pass

In [76]:

page = WebPage(0, 'web content')
page.to_html()

Out[76]:

'<html><body>web content</body></html>'

다중 상속 시 주의점¶

In [77]:

class A:
    def hello(self):
        print('Hello')

class B(A):
    def hello(self):
        print('Hola')
        super().hello()  # 베이스 클래스의 메서드를 실행

class C(A):
    def hello(self):
        print('안녕하세요')
        super().hello()  # 베이스 클래스의 메서드를 실행

class D(B, C):
    def hello(self):
        print('Xin Chao')
        super().hello()  # 베이스 클래스의 메서드를 실행

In [78]:

d = D()
d.hello()

Xin Chao
Hola
안녕하세요
Hello

mro 이용한 시용한 메서드 결정 순서 확인¶

In [79]:

D.__mro__  # 메서드 결정 순서 확인

Out[79]:

(__main__.D, __main__.B, __main__.C, __main__.A, object)

In [80]:

d.hello()

Xin Chao
Hola
안녕하세요
Hello