Class

# class

- self, 클래스, 인스턴스 변수

- 클래스(객체), 인스턴스 차이 중요

- 네임스페이스 : 각각의 객체를 인스턴스화 할 때 저장된 독립적 공간, 파이썬의 모든 자료형은 네임스페이스 가지고 있음.

- 클래스 변수 : 직접 사용 가능, 객체보다 먼저 생성

- 인스턴스 변수 : 객체마다 별도로 존재, 인스턴스 생성 후 사용

# (1)

class A: ( # 클래스 이름 -> 첫글자 대문자로 하는 것이 원칙, 단어와 단어 연결할 경우 연결된 단어 첫글자도 대문자. ) 
    ( # 속성, 메소드 )
    pass ( # pass : 클래스 안에 내용 없어도 에러 안남. )
    

class UserInfo:
    def __init__(self, name):  	( # __init__(self) : 클래스를 초기화할때 호출되는 함수, 구현해줘야 함. name -> 속성 )
        self.name = name
    def user_info_p(self):
        print("NAME : ", self.name)

네임스페이스 -> 인스턴스화 된 변수( ex) user1)가 갖고 있는 자기 자신의 공간 , user1= user2

user1 = UserInfo("Kim")  (# user1 -> 인스턴스 생성 )
print(user1.name) # Kim
user1.user_info_p() # NAME :  Kim
user2 = UserInfo("Park") 
print(user2.name) # Park
user2.user_info_p() # NAME :  Park

user1 id값과 user2 id 값이 다른 것을 알 수 있음

print(id(user1)) # 2204931182896
print(id(user2)) # 2204931183040

namespace 출력

print(user1.__dict__) # {'name': 'Kim'}
print(user2.__dict__) # {'name': 'Park'}

# (2)

- self 이해

- 인스턴스 생성하는 메소드는 self인자가 자동으로 넘어간다 ~!

- self가 없는 것들은 class에서 직접 호출한다~!

class SelfTest(): 	 # 클래스 선언 시 ()없어도 됨. 
    def function1(): 	 # 클래스 메소드, self 인자가 없기때문에 인스턴스 에서는 호출할 수 없음. 공통 함수로서 클래스에서 직접 호출. 여러 인스턴스 들이 공유하는 함수, 호출할 때는 클래스 이름으로 호출. 
        print('function1 called~!')
    def function2(self): 	 # 인스턴스 메소드 (self 있으면)  
        print('function2 called~!')
        print(id(self))

self_test = SelfTest() 
SelfTest.function1() # function1 called~!  # 클래스 메소드 -> 클래스 이름으로 호출 
self_test.function2() # function2 called~! 
			2204931183136       # 인스턴스 메소드 -> 1) 인스턴스 생성해서 호출하거나 

print(id(self_test)) # 2204931183136
# SelfTest.function2() # 이렇게 하면 오류 남, 아래처럼 인자 넣어줘야함. 
SelfTest.function2(self_test)  # function2 called~!
			       # 2204931183136 (# 인스턴스 메소드 -> 2) 클래스를 즉시 호출 하는데 인자를 넣어줌 )

# (3)

- 클래스 변수(self 없음), 인스턴스 변수(self)

class WareHouse:
     # 클래스 변수 -> 모두가 공유 
     # 연봉인상율 
    stock_num = 0
    def __init__(self, name):   # 인스턴스 생성시 init메소드 호출되니까 self 받아야함. 
        self.name = name
        WareHouse.stock_num += 1
    def __del__(self):
        WareHouse.stock_num -= 1


user1 = WareHouse('Kim')
user2 = WareHouse('Park')
user3 = WareHouse('Lee')

print(user1.__dict__) # {'name': 'Kim'}
print(user2.__dict__) # {'name': 'Park'}
print(user3.__dict__) # {'name': 'Lee'}
print(WareHouse.__dict__) # {'__module__': '__main__', 'stock_num': 3, '__init__': <function WareHouse.__init__ at 0x0000020160225940>, '__del__': <function WareHouse.__del__ at 0x0000020160225B80>, '__dict__': <attribute '__dict__' of 'WareHouse' objects>, '__weakref__': <attribute '__weakref__' of 'WareHouse' objects>, '__doc__': None}( # 클래스 네임스페이스, 클래스 변수(공유) )

print(user1.name) # Kim
print(user2.name) # Park
print(user3.name) # Lee

print(user1.stock_num) # 3 ( # 본인 네임스페이스에 없으면 class의 네임스페이스에서 변수 찾음. )
print(user2.stock_num) # 3
print(user3.stock_num) # 3

del user1
print(user2.stock_num) # 2
print(user3.stock_num) # 2

# class 상속, 다중상속

# (1)

- 상속 기본

- 슈퍼클래스(부모) 및 서브클래스(자식) -> 모든 속성과 메소드를 사용 가능.

- 라면 -> 속성(종류, 회사, 맛, 면종류, 이름) : 부모 ( 공통으로 사용할 수 있는 속성 )

class Car:
    """Parent Class"""
    def __init__(self, tp, color):
        self.type = tp
        self.color = color

    def show(self):
        return 'Car Class "Show Method!"'
    
class BmwCar(Car): 	 # Car 클래스 상속 = 슈퍼클래스는 Car클래스가 됨. 
    """Sud Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name
    
    def show_model(self) -> None:  	 # None 없다는 힌트 
        return "Your Car Name :%s" % self.car_name


class BenzCar(Car):
    """Sud Class"""
    def __init__(self, car_name, tp, color):
        super().__init__(tp, color)
        self.car_name = car_name
    
    def show_model(self) -> None: 	 # None 없다는 힌트 
        return "Your Car Name :%s" % self.car_name
    
    def show(self):
        print(super().show()) 		 # 자식의 show가 호출 되겠지만, 부모의 show도 호출하고 싶으면. 
        return 'Car Info : %s %s %s ' % (self.car_name, self.type, self.color)

일반 사용

model1 = BmwCar('520d', 'sedan','red')

print(model1.color) # red   (슈퍼클래스 (부모에서 가져온 것)) 
print(model1.type) # sedan (슈퍼클래스)  
print(model1.car_name)  /# 520d  (서브클래스) 
print(model1.show()) # Car Class "Show Method!" (슈퍼클래스)
print(model1.show_model()) # Your Car Name :520d (슈퍼클래스)
print(model1.__dict__) # {'type': 'sedan', 'color': 'red', 'car_name': '520d'}

Method Overriding (오버라이딩) -> 알아야 다른 개발자의 소스 , 오픈소스 , 기존 패키지 안에있는 모듈 소스 들을 분석가능

model2 = BenzCar("220d", "suv", "black")
print(model2.show())    # Car Class "Show Method!" 
			# Car Info : 220d suv black(슈퍼, 서브클래스에 같은 메소드 있으면 서브클래스에 있는 메소드 실행. -> show() , 오버라이딩, 코드 재활용 )

Parent Method Call

model3 = BenzCar("350s", "sedan", "silver")
print(model3.show()) # Car Class "Show Method!"
		     # Car Info : 350s sedan silver

Inheritance Info

print(BmwCar.mro())  # mro : 알고싶은 클래스의 상속 관계 정보를 리스트 타입으로 반환 ( 상속방향 : 출력 된 내용의 왼쪽에서 오른쪽으로 ) 
 		     # [<class '__main__.BmwCar'>, <class '__main__.Car'>, <class 'object'>]
 
print(BenzCar.mro()) #[<class '__main__.BenzCar'>, <class '__main__.Car'>, <class 'object'>]

# (2)

- 다중 상속

- 너무나 복잡한 다중상속은 코드를 해석하기가 어려울 수 있음. 보통은 2개 정도 상속받음.

class X():
    pass

class Y():
    pass

class Z():
    pass

class A(X, Y):
    pass

class B(Y, Z):
    pass

class M(B, A, Z):
    pass

print(M.mro()) # [<class '__main__.M'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class '__main__.Z'>, <class 'object'>]
print(A.mro()) # [<class '__main__.A'>, <class '__main__.X'>, <class '__main__.Y'>, <class 'object'>]