[Python] 객체와 클래스

<목차>

📁 객체 지향 프로그래밍(Object Oriented Programming, OOP)

 

📁 객체(Object)

✔️ 숫자에서 함수까지 파이썬의 모든 것은 객체다. 

num = 7을 입력했을 때 7이 담긴 정수 유형의 객체를 생성하고 객체 참조(object reference)를 num에 할당한다. 

 

✔️ 객체는 데이터(변수, 속성)와 코드(함수, 메서드)를 포함하는 커스텀 자료구조이다. 

함수 : 객체 외의 코드 뭉치
메서드 :  클래스 안의 멤버 외의 코드 뭉치

 

✔️ 객체는 구체적인 어떤 것의 유일한 인스턴스(instance)를 가리킨다.

✔️ 객체는 정의된 클래스를 통해 생성된다. 객체 != 클래스

 

📁 클래스(Class)

✔️ 객체의 틀을 나타낸다. 

class Cat:
    pass

 

✔️ Cat()은 Cat 클래스로부터 개별 객체를 생성하여 객체 참조를 a_cat과 another_cat에 할당한다. 

- a_cat과 another_cat은 같은 클래스의 다른 객체이므로 다르게 맵핑된다. 

a_cat = Cat()
another_cat = Cat()

print(a_cat)
<__main__.Cat object at 0x000002050461D9A0>

print(another_cat)
<__main__.Cat object at 0x000002050461DD30>

 

📁 속성(Attribute)

✔️ 속성은 클래스나 객체 내부의 변수다.

✔️ 객체나 클래스가 생성되는 동안에도 생성 가능하지만 생성 이후에도 속성을 추가 작성할 수 있다. 

# Cat 클래스에 선언되어 있지 않은 속성을 추가로 사용 가능
a_cat.age = 3
a_cat.name = "cat"
a_cat.nemesis = another_cat

a_cat.age
Out[102]: 3

a_cat.name
Out[100]: 'cat'

a_cat.nemesis
Out[101]: <__main__.Cat at 0x2050461dd30>

 

📁 메서드(Method)

✔️ 메서드는 클래스 또는 객체의 함수다. 

✔️ __init__() : 개별 객체를 초기화하는 특수 메서드

__init__() 메서드는 다른 언어에서의 "생성자"의 개념이 아니다.
__init__() 메서드 호출 전에 이미 객체가 만들어져 있기 때문이다. 

✔️ self : 개별 객체 자신을 참조

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

self.name의 경우 명시적으로 클래스의 속성으로 선언되어 있지는 않지만 클래스 내에 속성으로써 사용 가능하다. 

 

📁 객체 상속

📄 상속(inherit)

객체의 주요 특성 : 캡슐화, 상속, 추상화, 다형성

✔️ 필요한 기능은 기존의 것을 사용하자!! 재사용!!

 

- 부모 클래스 : 기존의 것

- 자식 클래스 : 파생된 것, sub class

class Car:
	pass
class Yugo(Car):
	pass

 

✔️ issubclass(a, b) : a가 b의 서브 클래스 인가?

issubclass(Yugo, Car)
Out[15]: True

 

💡 data type의 상속

bool은 int의 서브 클래스이다. = bool은 int를 상속받는다. 

issubclass(bool, int)
Out[21]: True

issubclass(int, bool)
Out[23]: False

issubclass(int, float)
Out[22]: False

issubclass(float, int)
Out[25]: False

 

isinstance()

 

📄 자식 클래스

✔️ 부모 클래스의 특징을 가져올 수 있다. (= 상속 받는다.)

특징 : 메서드, 멤버, 동작 과정 등

class Car():
	def exclaim(self):
		print("I am a Car!")
class Yugo(Car):
	pass

give_me_a_car = Car()
give_me_a_yugo = Yugo()

give_me_a_car.exclaim()
I am a Car!

give_me_a_yugo.exclaim()
I am a Car!

 

✔️ 자식 클래스만의 새로운 기능을 정의할 수 있다. 

메서드 명이 새롭다면 새롭게 정의되고, 메서드 명이 같다면 재정의(override) 된다. 

 

📄 오버라이드(override, 재정의)

override vs overload

class Car():
	def exclaim(self):
		print("I am a Car!")
class Yugo(Car):
	def exclaim(self):
		print("I am a Yugo!")

give_me_a_car = Car()
give_me_a_yugo = Yugo()

give_me_a_car.exclaim()
I am a Car!

give_me_a_yugo.exclaim()
I am a Yugo!

 

✔️ __init__() 메서드도 오버라이드 된다. 

class Person:
    def __init__(self, name):
        self.name = name
        
class MDPerson(Person):
    def __init__(self, name):
        self.name = "Doctor " + name
        
class JDPerson(Person):
    def __init__(self, name):
        self.name = name + ", Esquire"

person = Person("Riri")
doctor = MDPerson("Riri")
lawyer = JDPerson("Riri")

person.name
Out[53]: 'Riri'

doctor.name
Out[52]: 'Doctor Riri'

lawyer.name
Out[54]: 'Riri, Esquire'

 

📄 Super()

✔️ 상속받은 객체가 부모 객체를 요청할 때 사용한다.

✔️ 부모 클래스의 정의를 얻어온다. 

 

✔️ super().__init__(name)

부모 클래스의 name을 인수로 받아온 name으로 초기화 해준다. 

→ 자식 클래스에서 __init__() 메서드를 오버라이드 해서 사용했기 때문에 이를 쓰지 않으면 부모 클래스의 __init__() 함수가 실행되지 않기 때문에 사용해야한다. 

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

bob = EmailPerson("Bob Frapples", "bob@frapples.com")

bob.name
Out[31]: 'Bob Frapples'

bob.email
Out[32]: 'bob@frapples.com'

 

📄 다중 상속

✔️ 객체는 여러 부모 클래스를 상속받을 수 있다. 

class Animal:
	def says(self):
		return "I speak"
        
class Horse(Animal):
	def says(self):
		return "Neigh"
    
class Donkey(Animal):
	def says(self):
		return "Hee-haw"
    
class Mule(Donkey, Horse):
	pass
    
class Hinny(Horse, Donkey):
	pass

 

💡 메서드 해석 순서 - mro()

다음과 같은 순서로 클래스에서 메서드나 속성을 찾는다. 

객체 자신 → 객체의 클래스 → 첫번째 부모 클래스 → 두번째 부모 클래스 → 부모 클래스

Mule.mro()
Out[34]: [__main__.Mule, __main__.Donkey, __main__.Horse, __main__.Animal, object]

Hinny.mro()
Out[35]: [__main__.Hinny, __main__.Horse, __main__.Donkey, __main__.Animal, object]

mule = Mule()
hinny = Hinny()

mule.says()
Out[43]: 'Hee-haw'

hinny.says()
Out[44]: 'Neigh'

 

📄 믹스인 / 컴포지션

 

📁 객체 속성 접근 - 캡슐화 

Python vs Java

📄 직접 접근

✔️ 파이썬은 일반적으로 객체 속성과 메서드가 공개되어 있어 직접 접근이 가능하다. 

✔️ 하지만 다음과 같이 클래스 외부에서 볼 수 없도록 셋팅한 속성(private attribute)에는 접근하지 못한다. 

class Blink():
    def __init__(self, input_name, input_pw):
        self.name = input_name
        self.__password = input_pw

blink = Blink("Riri", "ilovelisa")

blink.name
Out[84]: 'Riri'

blink.__password
Traceback (most recent call last):
  File "C:\Anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 3437, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-85-94be706f037f>", line 1, in <module>
    blink.__password
AttributeError: 'Blink' object has no attribute '__password'

blink.password
Traceback (most recent call last):
  File "C:\Anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 3437, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-86-122aad938aa4>", line 1, in <module>
    blink.password
AttributeError: 'Blink' object has no attribute 'password'

 

💡 네임 맹글링(name mangling)

클래스 정의를 외부에서 볼 수 없도록 하는 속성에 대한 네이밍 컨벤션(naming convention)이다. 

 

- 속성 이름 앞에 두 언더바(__)로 적용

- 속성의 의도적인 직접 접근을 어렵게 만든다. 

- private attribute : 디버깅할 때  보이지 않는다. = 런타임에서 보이지 않는다.

 

다음과 같은 방식으로 접근할 수 있다. 

blink._Blink__password
Out[93]: 'ilovejisso'

 

📄 Getter/Setter 메서드

class Blink():
    def __init__(self, input_name, input_pw):
        self.name = input_name
        self.__password = input_pw
    def get_pw(self):
        print("inside the getter")
        return self.__password
    def set_pw(self, input_pw):
        print("inside the setter")
        self.__password = input_pw

blink = Blink("Riri", "ilovelisa")

blink.name
Out[75]: 'Riri'

blink.get_pw()
inside the getter
Out[76]: 'ilovelisa'

blink.set_pw("ilovejennie")
inside the setter

blink.get_pw()
inside the getter
Out[78]: 'ilovejennie'

 

📄 프로퍼티 (@property)

class Blink():
    def __init__(self, input_name, input_pw):
        self.name = input_name
        self.__password = input_pw
    @property
    def password(self):
        print("inside the getter")
        return self.__password
    @password.setter
    def password(self, input_pw):
        print("inside the setter")
        self.__password = input_pw

blink = Blink("Riri", "ilovelisa")

blink.name
Out[89]: 'Riri'

blink.password
inside the getter
Out[90]: 'ilovelisa'

blink.password = "ilovejisso"
inside the setter

blink.password
inside the getter
Out[92]: 'ilovejisso'

 

💡 계산된 값의 프로퍼티

프로퍼티는 계산된 값(computed value)를 참조할 수 있다. 

class Circle:
    def __init__(self, radius):
        self.radius = radius
    @property
    def diameter(self):
        return 2 * self.radius
    
c = Circle(5)

c.radius
Out[105]: 5

c.diameter
Out[106]: 10

c.radius = 7
c.diameter
Out[108]: 14

# seter property를 명시하지 않으면 외부로부터 이 속성을 설정할 수 없다. 
c.diameter = 28
Traceback (most recent call last):
  File "C:\Anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 3437, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-109-23b5625e22cc>", line 1, in <module>
    c.diameter = 28
AttributeError: can't set attribute

 

📁 메서드 타입

📄 인스턴스 메서드

 

📄 클래스 메서드

@classmethod

매개변수를 cls로 사용

class A:
    count = 0
    def __init__(self):
        A.count += 1
    def exclaim(self):
        print("I am an A!")
    @classmethod
    def kids(cls):
        print(f"A has {cls.count} little objects")

easy_a = A()
breezy_a = A()
wheezy_a = A()

A.kids()
A has 3 little objects

 

 

📄 정적 메서드

✔️ 클래스를 통한 객체 생성이 필요 없다. 

     → 객체 생성은 무거운 연산!!

class CoyoteWeapon:
    @staticmethod
    def commercial():
        print("This coyoteweapon has been what?")
        
CoyoteWeapon.commercial()
This coyoteweapon has been what?

 

📁 덕타이핑

사림이 오리처럼 행동하면 오리로 봐도 무방하다는 개념

✔️ 타입을 미리 정하지 않고 런타임에 해당 메소드들을 확인하며 결정한다. 

 

💡 다형성

하나의 객체가 여러 가지 타입을 가질 수 있는 것

파이썬은 다형성을 느슨하게 구현한다. 

클래스에 상관 없이 같은 동작을 다른 객체에 적용할 수 있다. 

class Parrot:
    def fly(self):
        print("Parrot flying")
class Airplane:
    def fly(self):
        print("Airplane flying")
class Whale:
    def swim(self):
        print("Whale swimming")
def lift_off(entity):
    entity.fly()

 

✔️ 다 다르게 동작한다. 

parrot = Parrot()
airplane = Airplane()
whale = Whale()

lift_off(parrot) 
Parrot flying

lift_off(airplane)
Airplane flying

lift_off(whale)
Traceback (most recent call last):
  File "C:\Anaconda\lib\site-packages\IPython\core\interactiveshell.py", line 3437, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-12-d95e9c850c52>", line 1, in <module>
    lift_off(whale)
  File "<ipython-input-8-4c503ff8deae>", line 14, in lift_off
    entity.fly()
AttributeError: 'Whale' object has no attribute 'fly'

 

매직 메서드

__<func>__

 

round 함수

floor 바닥 함수

ceil 천장 함수

 

애그리게이션 / 콤퍼지션

상속을 통해 기능을 물려받는것이 아닌 접근 방법

 

믹스인

다중 상속의 복잡성을 해소하기 위한 방법

대체적으로 애그리게이션 / 콤퍼지션을 활용

믹스인 (is-a) 애그리게이션 / 콤퍼지션 (has-a)

 

클래스 내에 객체를 삽입

 

네임드 튜플

Dataclass가 등장하기 전에 활용되던 타입

 

 

 

---

Ref.

- 2021 청년취업 아카데미 파이썬 수업

- 처음 시작하는 파이썬, 빌 누바노빅