[Python]객체

Class

변수와 함수를 모두 가지고 있는 것이 Class이다.

Class는 객체를 만들기 위해서 사용을 한다.

객체를 만드는 방법은 다음과 같다.

객체변수 = 클래스명()

뒷부분에 있는 클래스명()을 생성자라고도 부른다.

이렇게 만들어진 객체 변수를 인스턴스라고도 부른다.

class BreadMold:
    category = "크림빵"

bread = BreadMold()

# 참조연산자.
print(bread.category)

이렇게 객체에 있는 변수를 호출해 사용할 수 있다.

사용할 때 객체 변수 뒤에 참조 연산자. 을 붙여서 사용하려는 함수나 변수를 사용할 수 있다.

이렇게 만들어진 객체는 객체 고유의 속성도 가질 수 있다.

예를 들어 위 코드에 가격이란 속성을 추가해보자.

class BreadMold:
    # 속성 == 일반적인변수
    category = "크림빵"


bread = BreadMold()
bread.price = 3000

# 참조연산자.
print("{}의 가격은 {}입니다.".format(bread.category,bread.price))

이렇게 bread객체의 고유한 속성으로 price를 추가해 사용할 수 있다.

또한 class는 함수도 가지고 있을 수 있다.

이렇게 class가 가지고 있는 함수를 메서드라고 부른다.

class BreadMold:
    category = "크림빵"
    def make_bread():
        print("빵을 만들어 냅니다.")

bread = BreadMold()

bread.make_bread()
→ Error

이렇게 BreadMold라는 Class안에 make_bread라는 메서드를 만들어 그 메서드를 출력하면 Error가 발생한다.

그 이유는 python에서는 컴파일하면서 메서드를 호출 시 객체 변수가 인자 값으로 들어가기 때문이다.

해결방법은 self라는 키워드를 사용해서 해결할 수 있다.

class BreadMold:
    category = "크림빵"
    def make_bread(self):
        print("빵을 만들어 냅니다.")

bread = BreadMold()

bread.make_bread()
→ 빵을 만들어 냅니다.

사실 self가 아닌 다른 이름을 넣어도 가능하지만, 자기 자신을 가리키는 self라는 이름을 넣는 것을 권장한다.

 

객체

사실 이때까지 class를 계속 사용해왔다.

int() , str() , float() , bool() , tuple()..... type()

앞서 배워왔던 모든 것이 다 class였기 때문이다.

number = 1 
text = "a"

print(type(number))
print(type(text))

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

이렇게 변수의 타입을 알려주는 type을 사용해서 출력해보면 type앞에 class가 붙어있다.

이것이 의미하는 것은 1이라는 데이터를 활용할 때는 int형의 인스턴스(객체)로 활용을 해왔다는 말이다.

number = 1 
a = 1

# id() = 객체의 주소값을 반환
print(id(number))
print(id(a))
print(id(1))

 

id()는 객체의 주소 값을 출력해준다.

이렇게 number과 a의 변수에 1을 할당해주고 정수형 1의 id값을 출력해주면 모두 같은 id가 출력이 된다.

이것이 의미하는 것은 2개의 변수와 정수 1은 모두 같은 객체라는 말이다.

number = 1 
a = 1.0

print(isinstance(number,int))
→ True

print(isinstance(a,in))
→ False

isinstance()는 앞에 우리가 사용할 객체를 입력해주고 그 뒤에 class명을 입력해주면 앞 객체가 뒤 클래스를 이용해서 만들어졌는지 확인해주는 내장 함수이다.

text1 = 12345
text2 = "12345"

print(id(text1),id(text2))

이렇게 정수 12345와 문자열 12345를 출력해보면 당연히 다른 주소 값이 출력된다.

text1 = 12345
text2 = "12345"

print(id(text1),id(text2))
print(id(text1),id(int(text2)))

하지만 만약 내장 함수라면 문자열을 int형으로 변환을 해도 주소 값이 동일해야 한다.

하지만 int형으로 변환 후 text2의 주소 값을 확인해보면 주소 값이 달라지는 것을 확인할 수 있다.

즉슨 , int라는 class에서 인자 값으로 text2를 받아서 새로운 객체를 생성한다는 말이다.

 

NameSpace - 이름 공간

 

class BreadMold:
    category = "빵"

bread1 = BreadMold()
bread2 = BreadMold()
bread3 = BreadMold()

bread1.price = 3000
bread2.category = "붕어빵"
bread3.category = "잉어빵"

print(bread1.category,bread2.category,bread3.category)
→ 빵 붕어빵 잉어빵

이렇게 BreadMold라는 class로 3개의 객체를 생성하고 2번 3번 객체에서는 category를 변경하였다.

그리고 bread1 객체에서는 pirce라는 변수와 3000이라는 값을 할당해주었다.

그리고 출력을 했을 시 각각 다른 빵이 출력이 된다.

이 말은 같은 클래스를 참조하였지만 서로 다른 객체이기 때문에 서로에게 영향을 주지 않는다.

# dir() 이름공간에 있는 모든 속성을 리스트로 반환

print(dir(bread1))
print(dir(bread2))
print(dir(BreadMold))

dir() 이름 공간에 있는 모든 속성을 리스트로 반환해준다,

dir()로 bread1과 bread2의 속성을 출력해보면 bread1에는 price가 있지만 bread2에는 price가 없다.

마찬가지로 BreadMold Class 또한 price가 없다.

 

__init__ 생성자 메서드

 

객체 변수 = 클래스명()에서 괄호()를 생성자라고 부른다.

class BreadMold:
    category = "빵"

    def __init__(self):
        print("빵을 만들었습니다.")

# __init__ 생성자 메서드
bread1 = BreadMold()
→ 빵을 만들었습니다.

생성자 메서드는 __init__이다.

생성자 메서드는 객체가 생성되는 순간 실행되는 메서드이다.

class BreadMold:
    category = "빵"

    def __init__(self, price):
        self.price = price
        print("빵을 만들었습니다.")

# __init__ 생성자 메서드
bread1 = BreadMold(3000)
print("첫번째 빵의 가격은 {}입니다.".format(bread1.price))

이렇게 생성하는 동시에 price 가격을 넣어주었기 때문에 , 따로 객체를 변경해줄 필요가 없다.

그리고 생성자 메서드에 매개변수를 넣고 , 생성할 때 인자를 주지 않으면 Error가 발생한다.

 

__del__ 소멸자 메서드

생성자 메서드__init__은 객체가 생성될 때 실행하는 메서드라면 __del__은 객체가 소멸될 때 실행되는 메서드이다.

소멸자 메서드 같은 경우에는 내가 참조하고 있던 어떤 객체를 객체 변수들이 더 이상 참조하고 있지 않을 때 실행이 된다.

이걸 레퍼런스 카운트라고 하는데 쉽게 생각하면 레퍼런스 카운트가 0이 되면 소멸자 메서드가 실행이 된다.

class BreadMold:
    category = "빵"

    def __init__(self,category , price):
        self.category = category
        self.price = price
        print("빵을 만들었습니다.")
    
    def __del__(self):
        print("빵이 없어졌습니다.")

# __init__ 생성자 메서드
bread1 = BreadMold("붕어빵" , 3000)
bread1 = BreadMold("빵" , 1000)
print("첫번째 빵의 가격은 {}입니다.".format(bread1.price))

↓
빵을 만들었습니다.
빵을 만들었습니다.
빵이 없어졌습니다.
첫번째 빵의 가격은 1000입니다.
빵이 없어졌습니다.

객체 bread1이 두 번 생성이 되면서 생성자 메서드를 두 번 호출한다.

그리고 bread1이 새로 생성될 때 기존에 있던 bread1이 참조하던 게 없어지면서 레퍼런스 카운트가 0이 되기 때문에,

소멸자 메서드를 호출한다.

그리고 print문이 실행이 되고 , print문이 끝나면서 프로그램이 종료가 되기 때문에 소멸자 메서드를 호출한다.

print(bread1)
→ <__main__.BreadMold object at 0x000002176D5BFFD0>

그리고 bread1을 출력을 하면 bread1이라는 객체의 메모리 주소가 나온다.

객체를 출력했을 경우에는 객체의 클래스에 __str__이라는 메서드가 출력이 된다.

 

__str__

__str__메서드는 객체를 문자열로 반환했을 때 출력 값을 지정해줄 수 있는 메서드이다.

class BreadMold:
    category = "빵"

    def __init__(self , category , price):
        self.category = category
        self.price = price
        print("빵을 만들었습니다.")

    def __str__(self):
        return "첫번째 빵의 가격은 {}입니다.".format(bread1.price)
    
    def __del__(self):
        print("빵이 없어졌습니다.")

bread1 = BreadMold("붕어빵" , 3000)
print(bread1)
→ 첫번째 빵의 가격은 3000입니다.

이렇게  __str__ 메서드에 아까 print문을 반환 값으로 지정을 해주면,

방금 같은 경우는 객체의 메모리 주소 값이 출력이 됐지만, 지금은 빵의 가격이 출력이 된다.

__str__메서드를 새로 원하는 내용으로 정의해주었기 때문이다.

 

상속

상속을 이용하면 상속하는 클래스의 모든 것을 사용할 수 있기 때문에 재사용성이 매우 좋아진다.

상속을 해주는 class는 super class 또는 부모 class라고 하고,

상속을 물려받는 class는 sub class 또는 자식 class이라고 한다.

class ParentRestaurant:
    def __init__(self, name, menu, recipe):
        self.name = name
        self.menu = menu
        self.recipe = recipe

    def __str__(self):
        return "가게 이름 : {}, 가게의 메뉴 : {}, 메뉴의 조리법 : {}".format(self.name, self.menu, self.recipe)
    
    def __del__(self):
        pass

class ChildRestaurant(ParentRestaurant):
    pass

restaurand_info = ChildRestaurant("자식의 가게" , "붕어빵" , "붕어빵을 굽는다.")

print(restaurand_info)
→ 가게 이름 : 자식의 가게, 가게의 메뉴 : 붕어빵, 메뉴의 조리법 : 붕어빵을 굽는다.

상속을 받을때는 상속받는 클래스 이름 옆에 괄호 안에 상속하는 클래스의 이름을 넣으면 된다.

그렇게 자식 생성자를 인스턴스화 해서 객체를 출력해보면 자식 클래스에는 pass 밖에 없지만,

부모 클래스를 물려받기 때문에 부모의 __str__이 출력되는 걸 확인할 수 있다.

또한 상위 클래스에서 정의한 속성을 하위 클래스에서 새로 정의할 수 있다.

class ParentRestaurant:
    price = 15000

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

    def __str__(self):
        return "가게 이름 : {}, 가게의 메뉴 : {}, 메뉴의 조리법 : {}".format(self.name, self.menu, self.recipe)
    
    def __del__(self):
        pass

class ChildRestaurant(ParentRestaurant):
    price = 20000

restaurant_info = ChildRestaurant("맛집" , "스테이크" , "잘 꾸우면 됨")

print(restaurant_info.price)
→ 20000

이렇게 부모 클래스에서 price는 15000으로 되어있지만,

자식 클래스에서 새로 20000으로 정의했기 때문에, 객체의 price를 출력해보면 20000이 출력되는 걸 확인할 수 있다.

이것을 재정의 즉 오버라이딩이라고 한다.

이렇게 재정의 오버라이딩은 메서드도 가능하다.

class ParentRestaurant:
    price = 15000

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

    def __str__(self):
        return "가게 이름 : {}, 가게의 메뉴 : {}, 메뉴의 조리법 : {}".format(self.name, self.menu, self.recipe)
    
    def __del__(self):
        pass

class ChildRestaurant(ParentRestaurant):
    price = 20000

    def __init__ (self, name, menu, recipe, marketing):
        ParentRestaurant.__init__(self,name,menu,recipe)
        self.marketing = marketing

    def __str__(self):
        return super().__str__() + ", 마케팅 방법 : {}" .format(self.marketing)

restaurand_info = ChildRestaurant("맛집" , "스테이크" , "잘 꾸우면 됨","온라인")

print(restaurand_info)
→ 가게 이름 : 맛집, 가게의 메뉴 : 스테이크, 메뉴의 조리법 : 잘 꾸우면 됨, 마케팅 방법 : 온라인

이렇게 생성자와 출력문을 오버 라이딩해서 출력을 하게 되면 객체를 생성할 때도 인자 값이 하나 더 필요하고,

출력문도 마켓팅 방법 : 온라인 이 추가돼서 출력된 걸 확인할 수 있다.

이렇게 생성자에서 부모의 매개변수를 가져올 때는 부모의 클래스 이름.메서드 이름(부모의 매개변수)을 활용해 가져오고,

추가할 변수는 새로 밑에 정의해주면 된다.

또한 반환 값 또한 super()를 통해 부모의 출력문을 가져오고 새로 추가할 내용을 옆에 추가해주면 된다.

 

issubclass()라는 함수는 어떤 A라는 클래스와 B라는 클래스가 있을 때

A클래스가 B클래스의 하위 클래스인지 확인이 가능하다.

print(issubclass(ChildRestaurant,ParentRestaurant)) → True
print(issubclass(ParentRestaurant,ChildRestaurant)) → False

이렇게 출력문을 통해 상속을 받고 있는지 확인이 가능하다.

 

모듈

python에서 모듈은 코드를 작성해놓은 파일이다. .py로 끝나는 파일들을 모듈이라고 한다.

간단하게 계산기를 예제로들어 확인해보자.

def add(num1,num2):
    print(num1 + num2)

def sub(num1,num2):
    print(num1 - num2)

def times(num1,num2):
    print(num1 * num2)

def dev(num1,num2):
    print(num1 / num2)

위 코드가 들어간 모듈은 calculator.py이다.

그리고 이 모듈을 사용할 모듈은 calculator_un.py이다.

모듈을 사용할때는 import를 사용하면 된다.

import 모듈명

import calculator

calculator.add(2,3) → 5
calculator.sub(20,10) → 10
calculator.times(10,2) → 20
calculator.dev(10,2) → 5.0

그리고 사용할 모듈명이 너무 길거나 하면 새로 지정해줄 수도 있다.

import 모듈명 as 사용할 모듈명

import calculator as c

c.add(1,1)
c.sub(2,1)
c.times(2,2)
c.dev(4,2)

혹은 내가 사용하고 싶은 함수만 따로 호출이 선언이 가능하다.

그럴 땐 from키워드를 사용하면 된다.

from calculator import add

add(10,12) → 22

이렇게 필요한  함수만 가져와서 사용할 경우 바로 호출이 가능하다.

또한 as키워드를 통해 이름도 새로 지정이 가능하다.

from calculator import add as a

a(10,12) → 22

또한 , 필요한 함수가 많을 경우 콤마(,)를 통해 여러 개의 함수도 선언할 수 있다.

from calculator import add , sub

add(10,12) → 22
sub(20,10) → 10