파이썬 중급 - 클래스

◾클래스

• 클래스 만들기 : class 키워드, 속성(변수), 기능(함수) 이용

# 클래스 만들기
class Car:  # 클래스 선언
    # 생성자, 속성
    def __init__(self, color, length):
        self.color = color
        self.length = length
    # 기능
    def doStop(self):
        print("STOP!!!")
    
    def doStart(self):
        print("START!!!")

    def printCarInfo(self):
        print('self.color : {}'.format(self.color))
        print('self.length : {}'.format(self.length))

• 객체 생성 : 클래스의 생성자 호출

# 객체 생성
car1 = Car('red', 200)
car2 = Car('blue', 300)

car1.printCarInfo()
car2.printCarInfo()

• 객체 속성 변경 : 점(.)으로 속성에 접근하여 변경

# 클래스 선언
class NewGenerationPC:
    def __init__(self, name, cpu, memory, ssd):
        self.name = name
        self.cpu = cpu
        self.memory = memory
        self.ssd = ssd

    def doExcel(self):
        print("EXCEL RUN!!")

    def doPhotoshop(self):
        print("PHOTOSHOP RUN!!")

    def printPCInfo(self):
        print("name : {}".format(self.name))
        print("cpu : {}".format(self.cpu))
        print("memory : {}".format(self.memory))
        print("ssd : {}".format(self.ssd))
        
# 객체 생성
myPC = NewGenerationPC('myPC', 'i5', '16G', '256G')
myPC.printPCInfo()
print('='*15)
friendPC = NewGenerationPC('friendPC', 'i7', '32G', '512G')
friendPC.printPCInfo()

# 속성 변경
myPC.cpu = 'i9'
myPC.memory = '64G'
myPC.ssd = '1T'
myPC.printPCInfo()

• 변수 : 객체의 메모리 주소를 저장하고 이를 이용해 객체 참조

class Robot:
    def __init__(self, color, height, weight):
        self.color = color
        self.height = height
        self.weight = weight

    def printRobotInfo(self):
        print('color : {}'.format(self.color))
        print('height : {}'.format(self.height))
        print('weight : {}'.format(self.weight))

rb1 = Robot('red', 200, 80)
rb2 = Robot('blue', 300, 120)
# 얕은 복사 : 객체를 가리키는 주소값이 복사된 것
# 따라서 rb1과 rb3이 가리키는 객체는 같다.
rb3 = rb1

rb1.printRobotInfo()
print('-'*15)
rb2.printRobotInfo()
print('-'*15)
rb3.printRobotInfo()

# rb1의 속성 변경
rb1.color = 'gray'
rb1.height = 250
rb1.weight = 100

# rb1과 rb3의 속성이 같음을 확인할 수 있다.
rb1.printRobotInfo()
print('-'*15)
rb2.printRobotInfo()
print('-'*15)
rb3.printRobotInfo()

---

◾얕은 복사와 깊은 복사

• 얕은 복사 : 객체 주소를 복사하는 것으로 객체 자체가 복사되지 않는다.
  • 하나의 객체에 접근하는 다른 변수가 생기는 것

# 얕은 복사
class TempCls:
    def __init__(self, n, s):
        self.number =n
        self.string = s
    def printClsInfo(self):
        print('self.number : {}'.format(self.number))
        print('self.string : {}'.format(self.string))

tc1 = TempCls(10, "hello")
tc2 = tc1

tc1.printClsInfo()
tc2.printClsInfo()

print('tc2의 값 변경---------')
tc2.number = 3.14
tc2.string = 'world'
# 같이 변경된 것을 확인할 수 있다.
tc1.printClsInfo()
tc2.printClsInfo()

• 깊은 복사 : 객체 자체를 복사하는 것으로 또 하나의 객체가 만들어진다.

# 깊은 복사
class TempCls:
    def __init__(self, n, s):
        self.number =n
        self.string = s
    def printClsInfo(self):
        print('self.number : {}'.format(self.number))
        print('self.string : {}'.format(self.string))

# 모듈 사용
import copy

tc1 = TempCls(10, "hello")
# copy : 새로운 객체를 만드는 함수
# 새로운 객체를 만들지만 속성의 경우 내부까지 전부 깊은 복사가 이루어지지 않는다.
# 속성으로 리스트, 딕셔너리 등이 있다면 이 부분은 얕은 복사가 이루어진다.
tc2 = copy.copy(tc1)
# deepcopy : 재귀를 통해 내부까지 모두 새로운 객체로 생성한다.
# tc2 = copy.deepcopy(tc1)

tc1.printClsInfo()
tc2.printClsInfo()

print('tc2의 값 변경---------')
tc2.number = 3.14
tc2.string = 'world'

tc1.printClsInfo()
tc2.printClsInfo()

---

◾클래스 상속

1. 단일 상속

• 상속 : 클래스는 다른 클래스를 상속하여 내 것처럼 사용할 수 있다.
  • class3 -> class2 -> class1
    • class2는 class1를 상속한다.(class1의 모든 기능 사용 가능)
    • class3은 class2를 상속한다.(class2와 class1의 모든 기능 사용 가능)
  • class 클래스명(상속받을 클래스명)

# 상속
class NormalCar:
    def drive(self):
        print('[NormalCar] drive() called!!')

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

class TurboCar(NormalCar):
    def turbo(self):
        print('[TurboCar] turbo() called!!')

# TurboCar 클래스의 객체에서 drive, back 사용
myTurboCar = TurboCar()
myTurboCar.drive()
myTurboCar.back()
myTurboCar.turbo()

2. 생성자

• 생성자 : 객체가 생성될 때 생성자를 호출하면 __init()__ 자동 호출
  • cal = Calculator()
  • Calculator() 생성자 호출
  • Calculator() __init__() 호출

# 생성자
class Calculator:

    def __init__(self):
        print("[Calculator] __init__() called!!")

for _ in range(10):
    cal = Calculator()    

• __init__() : 속성 초기화

# 생성자
class Calculator:

    def __init__(self, n1, n2):
        print("[Calculator] __init__() called!!")
        self.num1 = n1
        self.num2 = n2

cal = Calculator(10, 20)
print(cal.num1, cal.num2)

• super() : 상위 클래스 속성 초기화를 위해 사용

class P_Class:
    def __init__(self, pNum1, pNum2):
        print('[pClass] __init__()')
        self.pNum1 = pNum1
        self.pNum2 = pNum2

class C_Class(P_Class):
    def __init__(self, cNum1, cNum2):
        print('[cClass] __init__()')
        # 부모 클래스 초기화
        super().__init__(100, 200)
        
        self.cNum1 = cNum1
        self.cNum2 = cNum2

cClass = C_Class(10, 20)
print(cClass.pNum1, cClass.pNum2)
print(cClass.cNum1, cClass.cNum2)

3. 다중 상속

• 다중 상속 : 2개 이상의 클래스 상속
  • 남발하게 되면 중복되거나 코드가 복잡해질 수 있으므로 주의해야한다.

# 다중 상속
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()

4. 오버라이딩

• 오버라이딩(Overriding) : 하위 클래스에서 상위 클래스의 메서드를 재정의(override)

# 오버라이딩
class Robot:
    def __init__(self, c, h, w):
        self.color = c
        self.height= h
        self.weight = w

    def fire(self):
        print('미사일 발사!!')

    def printRobotInfo(self):
        print('color : {}'.format(self.color))
        print('height : {}'.format(self.height))
        print('weight : {}'.format(self.weight))

class NewRobot(Robot):
    def __init__(self, c, h, w):
        super().__init__(c, h, w)

    def fire(self):
        print('레이저 발사!!')

myRobot = NewRobot('red', 200, 300)
myRobot.printRobotInfo()
myRobot.fire()

---

◾추상 클래스

• 추상 클래스 : 상위 클래스에서 하위 클래스에 메서드 구현을 강요

# 추상 클래스
from abc import ABCMeta
from abc import abstractmethod
class AirPlane(metaclass = ABCMeta):
    # 선언만 한다.
    # 하위 클래스에서 구현하지 않으면 오류 발생
    @abstractmethod
    def flight(self):
        pass

class Airliner(AirPlane):
    # 메소드 구체화
    def flight(self):
        print('시속 400km/h 비행')

plane = Airliner()
plane.flight()