231123 Python_상속, 다중상속, method, staticmethod, classmethod, cls

■ 상속 
    #1) 클래스의 메소드 속성을 물려받는다.
    #2) 공통된 내용을 하나로 묶어서 관리할 수 있다. 

# 부모 클래스 생성

class Parents:
    def __init__(self, name, pn):
        self.name = name 
        self.pn = pn
    def show(self):
        print('이름 : {}, 전화번호: {}'.format(self.name, self.pn))

p = Parents('홍길동', '010-1000-0001')
p.show()

# 자식 클래스 생성

class Child(Parents): # Parents 클래스를 받아온다
    def __init__(self, name, pn, addr, sn):
        self.name = name
        self.pn = pn
        self.addr = addr
        self.sn = sn

# 부모 클래스에 있는 show 함수만 호출.

c = Child('홍하든', '010-0001-1000', '서울', '0000') 
c.show()

 

# Parents 클래스를 Child 클래스에 코드 넣기

class Parents:
    def __init__(self, name, pn):
        self.name = name 
        self.pn = pn
    def show(self):
        print('이름 : {}, 전화번호: {}'.format(self.name, self.pn))

 

 

p = Parents('홍길동', '010-1000-0001')
p.show()

# 코드의 간결함을 위해 __init__ 에 상속시킨 Parents 클래스 를 불러온다.

class Child(Parents): # Parents 클래스를 받아온다
    def __init__(self, name, pn, addr, sn):
        Parents.__init__(self, name, pn)
        self.addr = addr
        self.sn = sn
    def show(self):
        print("주소 : {}, 주민번호 : {}".format(self.addr, self.sn))

# 인스턴스 후 동일하게 호출

c = Child('홍하든', '010-0001-1000', '서울', '0000') 
c.show() # Parents 상속을 받아도 내 자신이 우선순위

# Parents 클래스 내용도 같이 출력하려 할때, Parents.show(self)를 작성

class Child(Parents): # Parents 클래스를 받아온다
    def __init__(self, name, pn, addr, sn):
        Parents.__init__(self, name, pn)
        self.addr = addr
        self.sn = sn
    def show(self):
        Parents.show(self)
        print("주소 : {}, 주민번호 : {}".format(self.addr, self.sn))

# Child 에있는 print() 내용도 같이 호출하고 싶다면 Parents.show 불러오기

c = Child('홍하든', '010-0001-1000', '서울', '0000') 
c.show()

# 여러 class를 상속받고 싶을 때, 

class Add:
    def add(self, x, y):
        return x+y

class Mlitiply:
    def mlitply(self, x, y):
        return x * y

class Divide:
    def divide(self, x, y):
        return x/y

# 상속해야 할 클래스안에 여러 class명 으로 나열

class Calculator(Add, Mlitiply, Divide): #class 명으로 나열
    def sub(sele, x, y):
        return x - y

 

# 인스턴스화 후 호출 가능

cal = Calculator()
cal.add(10,20)
cal.mlitply(2, 3)
cal.divide(10, 2)
cal.sub(10,2)

 

# method 

class Calc:
    def add_instance_method(self, arg1, arg2):
        return arg1 + arg2
    
    @staticmethod
    def add_static_method(arg1, arg2):
        return arg1 + arg2
    
    def add_class_method(arg1, arg2):
        return arg1 + arg2
    
    @classmethod
    def add_class_method_new(cls, arg1, arg2):
        return arg1 + arg2

# 인스턴스화 , 동일하게 호출

c = Calc()
c.add_instance_method(10, 20) # 인스턴스 메소드
Calc.add_instance_method(10, 20) # 인스턴스 메소드이기 때문에 클래스를 통해서 수행하면 오류발생

Calc.add_class_method(100, 200) # 클래스 메소드, 클래스명을 통해서 수행해야 함
c.add_class_method(100, 200) # 클래스 메소드이기 때문에 인스턴스를 통해서 수행하면 오류발생

# @staticmethod : 클래스 or 인스턴스를 통해서 처리하는 코디네이터
c.add_static_method(1000, 2000) # 인스턴스 메소드 
Calc.add_static_method(1000, 2000) # 클래스 메소드

# @classmethod : 클래스 or 인스턴스를 통해서 처리하는 코디네이터
c.add_class_method_new(1000, 2000)
Calc.add_class_method_new(1000, 2000)

# @staticmethod vs @classmethod : 상속 때 차이

 

# 부모 class 와 자식 class

class Parent:
    rate = 1.1
    
    @staticmethod
    def static_compute(value):
        return value * Parent.rate
    
    @classmethod
    def class_compute(cls, value):
        return value * Parent.rate

class Child(Parent):
    rate = 1.2

     
# 인스턴스화 후 호출

p = Parent()
p.static_compute(1000)
Parent.static_compute(1000)
p.class_compute(1000)
Parent.class_compute(1000)

c = Child()
c.static_compute(1000)
Child.static_compute(1000)
c.class_compute(1000)
Child.class_compute(1000)

# Parent.rate -> cls.rate : cls 로 변경, 호출하는 입장(상속)에서 호출된다

class Parent:
    rate = 1.1 # global 변수, class 변수
    
    @staticmethod
    def static_compute(value): # 무조건 부모속성만 호출
        return value * Parent.rate
    
    @classmethod
    def class_compute(cls, value): # 호출하는 입장에서 호출
        return value * cls.rate
    
class Child(Parent):
    rate = 1.2

# 호출값 변동

p = Parent()
p.static_compute(1000)
Parent.static_compute(1000)
p.class_compute(1000)
Parent.class_compute(1000)

c = Child()
c.static_compute(1000) # 부모 속성을 사용(무조건)
Child.static_compute(1000)
c.class_compute(1000) # 현재 호출하고 있는 클래스 속성을 사용한다.
Child.class_compute(1000)

# 다른 class 에 상속 가능

class Child1(Parent):
    rate = 1.5

# 인스턴스화 + 호출값 확인. 

c1 = Child1()
c1.static_compute(1000) # 부모 속성을 사용(무조건)
Child1.static_compute(1000)
c1.class_compute(1000) # 현재 호출하고 있는 클래스 속성을 사용한다.
Child1.class_compute(1000)