파이썬 Python : 클래스 상속

 

클래스 상속

: 클래스는 또 다른 클래스를 상속해서 기능을 내 것처럼 사용할 수 있다.

 

Class 1	◀─ (상속) ─ Class2는 Class1을 상속한다.	Class 2	◀─ (상속) ─ Class3은 Class2를 상속한다.	Class 3
		Class2는  Class1의 모든 기능을 사용할 수 있다.		Class3은  Class2, Class1의 모든 기능을 사용할 수 있다.

 

 

 

  【   class  클래스명  (상속받을 클래스명)   】     

class NormalCar:
	def drive(self):
    	print('[NormalCar] dirve() called~!')

	def back(self):
    	print('[NormalCar] back() called~!')


class TurboCar(NormalCar):  # NormalCar 클래스를 상속받음
	def turbo(self):
    	print('[TurboCar] turbo() called~!')


myTurboCar = TurboCar()

myTurboCar.turbo()

myTurboCar.drive() # TurboCar 클래스가 NormalCar 클래스를 상속받았기 때문에 drive() 사용가능
myTurboCar.back() # TurboCar 클래스가 NormalCar 클래스를 상속받았기 때문에 back() 사용가능

 

 

[실습] 덧셈, 뺄셈 기능이 있는 클래스를 만들고, 이를 상속하는 클래스를 만들어서 곱셈과 나눗셈 기능을 추가해보자.

 

 

 

728x90

 

 

  【  super( )   】     

: 상위 클래스의 속성을 초기화하는데 super( )를 이용한다.

class P_class:
	def __init__(self, pNum1, pNum2):
		print('[P_class] __init__() called~!')
        
        self.pNum1 = pNum1
        self.pNum2 = pNum2


class C_class(P_class):
	def __init__(self, cNum1, cNum2):
		print('[C_class] __init__() called~!')
        
        self.cNum1 = cNum1
        self.cNum2 = cNum2
        
        
cls = C_class(10, 20)
# C_class 클래스의 __init__ 메소드는 호출되지만,
# P_class 클래스의 __init__ 메소드는 호출되지 않는다.

# __init__ 메소드가 호출되지 않으면, 속성도 초기화되지 않는다.
# 하여, P_class 클래서의 pNum1, pNum2 속성은 사용할 수가 없다.

-- 출력 -- [C_class] __init__() called~!

 

 

• 기능은 상속만 하면 바로 쓸수 있으나, 속성은 __init__ 메소드를 호출해야지 초기화해서 사용할 수 있다.

class P_class:
	def __init__(self, pNum1, pNum2):
		print('[P_class] __init__() called~!')
        
		self.pNum1 = pNum1
		self.pNum2 = pNum2


class C_class(P_class):
	def __init__(self, cNum1, cNum2):
		print('[C_class] __init__() called~!')
        
		# P_class 클래스의 __init__ 메소드 강제 호출
		# P_class.__init__(self, cNum1, cNum2)
        
		#부모 클래스의 __init__ 메소드 강제 호출
		super().__init__(cNum1, cNum2)
        
		self.cNum1 = cNum1
		self.cNum2 = cNum2
        
        
cls = C_class(10, 20)

-- 출력 -- [C_class] __init__() called~! [P_class] __init__() called~!

 

 

[실습] 중간고사 클래스와 기말고사 클래스를 상속관계로 만들고 각각의 점수를 초기화하자.
또한 총점 및 평균을 반환하는 기능도 만들어 보자.

class MidExam:
	def __init__(self, s1, s2, s3):
		print('[MidExam] __init__() called~!')
        
		self.mid_kor_score = s1
		self.mid_eng_score = s2
		self.mid_math_score = s3
        
	def printScore(self):
		print(f'.mid_kor_score: {self.mid_kor_score}')
		print(f'.mid_eng_score: {self.mid_eng_score}')
		print(f'.mid_math_score: {self.mid_math_score}')



class EndExam(MidExam):
	def __init__(self, s1, s2, s3, s4, s5, s6):
		print('[EndExam] __init__() called~!')
        
		super().__init__(s1, s2, s3)
        
		self.end_kor_score = s4
		self.end_eng_score = s5
		self.end_math_score = s6
        
	def printScore(self):		#점수 출력
		super().printScore()
        
		print(f'.end_kor_score: {self.end_kor_score}')
		print(f'.end_eng_score: {self.end_eng_score}')
		print(f'.end_math_score: {self.end_math_score}')

	def getTotalScore(self):	#총점 출력
		total = self.mid_kor_score + self.mid_eng_score + self.mid_math_score
		total += self.end_kor_score + self.end_eng_score + self.end_math_score        
		return total

	def getAverageScore(self):	#평균 출력
		return self.getTotalScore() / 6



exam = EndExam(85, 90, 80, 88, 75, 95)
exam.printScore()

print(f'Total: {exam.getTotalScore()}')
print(f'Avarage: {round(exam.getAverageScore(), 2)}')

 

 

 

 

 

다중 상속

2개 이상의 클래스를 상속한다.

다중상속은 남발하면 좋지 않다.

(클래스 안의 메소드명이 동일하거나 중복된 코드가 있을 경우에는 개발이 힘들며, 흔히 말하는 다중 상속의 늪에 빠질 수 있다.)

Car01	Car02	Car03
▲ ▲                            │                           ▲ │                           │                          │ └──────┼──────┘ │
	Car

 

  【   class  클래스명  (상속받을 클래스명, 상속받을 클래스명, … )   】     

class Car01:
	def drive(self):
		print('drive() method called~!')

class Car02:
	def turbo(self):
		print('turbo() method called~!')

class Car03:
	def fly(self):
		print('fly() method called~!')


class Car(Car01, Car02, Car03):	#다중상속
	def __init__(self):
		pass


myCar = Car()

myCar.drive()
myCar.turbo()
myCar.fly()

 

 

 

[실습] 다음의 BasicCalculator와 DeveloperCalculator 클래스를 상속해서 Calculator 클래스를 만들고 사용해보자.

class BasicCalculator:
	def add(self, n1, n2):
		return n1 + n2

	def sub(self, n1, n2):
		return n1 - n2
        
	def mul(self, n1, n2):
		return n1 * n2
        
	def div(self, n1, n2):
		return n1 / n2
        

class DevelopCalculator:
	def mod(self, n1, n2):
		return n1 % n2
        
	def flo(self, n1, n2):
		return n1 // n2
        
	def exp(self, n1, n2):
		return n1 ** n2


class Calculator(BasicCalculator, DevelopCalculator):
	def __init__(self):
		pass
        
        
cal = Calculator()

print(f'cal.add(10, 20): {cal.add(10, 20)}')
print(f'cal.sub(10, 20): {cal.sub(10, 20)}')
print(f'cal.mul(10, 20): {cal.mul(10, 20)}')
print(f'cal.div(10, 20): {cal.div(10, 20)}')

print(f'cal.mod(10, 20): {cal.mod(10, 20)}')
print(f'cal.flo(10, 20): {cal.flo(10, 20)}')
print(f'cal.exp(10, 20): {cal.exp(10, 3)}')