객체지향 프로그래밍

 

 

클래스=현실 세계의 사물을 컴퓨터 안에서 구현하려고 고아뇐 개념

 

속성=필드

클래스 안 함수= 매소드

 

Code12-01.py

#class 이름 앞글자는 대문자/ 붕어빵 틀
#class 안에 함수는 메소드
#class 사용 -> 객체
#클래스로 만든게 인스턴스디 / 인스턴스마다 인스턴스 변수가 다르다
#클래스 안에 변수는 필드
#필드는 값을 저장
#메소드는 작업
#클래스(설계도)->인스턴스(실제 자동차/클레스로 만들어낸 객체를 부르는 명칭)


class Car :
    color = ""
    speed = 0.

    def upSpeed(self, value):
        self.speed += value
    
    def downSpeed(self, value):
        self.speed -= value

-self.speed->자신의 클래스에 있는 speed 변수

-매소드(self, value)-self는 사용안되고 value만 사용된다

-self를 사용하는 이유는 필드에 접근하기 위해서다.

 

 

 

인스턴스->실제로 구현 됨=객체

 

Code12-02.py

#클래스 선언 부분
class Car :
    color = "" #필드선언
    speed = 0

    def upSpeed(self, value): #매서드선언
        self.speed += value
    
    def downSpeed(self, value):
        self.speed -= value

# 메인 코드 부분
myCar1 = Car()          #인스턴스
myCar1.color = "빨강"    #인스턴스 필드명 = 값
myCar1.speed = 0          #매소드 

myCar2 = Car()
myCar2.color = "파랑"
myCar2.speed = 0

myCar3 = Car()
myCar3.color = "노랑"
myCar3.speed = 0

myCar1.upSpeed(30) #인스턴스 매서드()
print("자동차1의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar1.color, myCar1.speed))

myCar2.upSpeed(60)
print("자동차2의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar2.color, myCar2.speed))

myCar3.upSpeed(0)
print("자동차3의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar3.color, myCar3.speed))

-

 

 

selfstudy12-1.py

# 클래스 선언 부분
class Car:
    color = ""  # 필드 선언
    speed = 0

    def upSpeed(self, value):  # 메서드 선언
        self.speed += value
        if self.speed > 150:  # 최대 속도 제한
            self.speed = 150

    def downSpeed(self, value):
        self.speed -= value

# 메인 코드 부분
myCar1 = Car()  # 인스턴스
myCar1.color = "빨강"
myCar1.speed = 0

myCar2 = Car()
myCar2.color = "파랑"
myCar2.speed = 0

myCar3 = Car()
myCar3.color = "노랑"
myCar3.speed = 0

myCar1.upSpeed(200)  # 150으로 제한됨
print("자동차1의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar1.color, myCar1.speed))

myCar2.upSpeed(60)
print("자동차2의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar2.color, myCar2.speed))

myCar3.upSpeed(0)
print("자동차3의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar3.color, myCar3.speed))

 

 

생성자 = 인스턴스르 생성하면 무조건 호출되는 매서드

인스턴스를 생성하면서 필드값을 초기화시키는 함수

 

Code12-03.py

#클래스 선언 부분
class Car :
    color = "" #필드선언
    speed = 0

    def __init__(self):
        self.color = "빨강"
        self.speed = 0

    def upSpeed(self, value): #매서드선언
        self.speed += value
    
    def downSpeed(self, value):
        self.speed -= value

# 메인 코드 부분
myCar1 = Car()#인스턴스
myCar2 = Car()

print("자동차1의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar1.color, myCar1.speed))
print("자동차2의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar2.color, myCar2.speed))

-init은 self외에 별도의 매개변수가 없는 생성자를 기본 생성자라 한다

 

Code12-04.py

#클래스 선언 부분
class Car :
    color = "" #필드선언
    speed = 0

    def __init__(self, value1, value2):
        self.color = value1
        self.speed = value2

    def upSpeed(self, value): #매서드선언
        self.speed += value
    
    def downSpeed(self, value):
        self.speed -= value

# 메인 코드 부분
myCar1 = Car("빨강", 30)  #인스턴스
myCar2 = Car("파랑", 60)

print("자동차1의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar1.color, myCar1.speed))
print("자동차2의 색상은 %s이며, 현재 속도는 %dkm입니다." % (myCar2.color, myCar2.speed))

-매개변수가 있는 생성자

 

Code12-05.py

#클래스 선언 부분
class Car :
    name = "" #필드선언
    speed = 0

    def __init__(self, name, speed):
        self.name = name
        self.speed = speed

    def getName(self): #매서드선언
        return self.name
    
    def getSpeed(self):
        return self.speed

#변수선언 부분
car1, car2 = None, None

# 메인 코드 부분
car1 = Car("아우디", 0)#인스턴스
car2 = Car("벤츠", 0)

print("%s의 현재 속도는 %dkm입니다." % (car1.getName(), car1.getSpeed()))
print("%s의 현재 속도는 %dkm입니다." % (car2.getName(), car2.getSpeed()))

-getName(), getSpeed()메서드를 사용해서 자동차 이름과 속도를 반환하고  값을 알아낸다.

 

Code12-06.py

#클래스 선언 부분
class Car :
    color = "" #인스턴스 변수
    speed = 0 #인슽너스 변수
    count = 0 #클래스 변수

    def __init__(self):
        self.speed = 0
        Car.count += 1

#변수선언 부분
car1, car2 = None, None

# 메인 코드 부분
myCar1 = Car()
myCar1.speed = 30
print("자동차1의 현재 속도 %dKM, 생산된 자동차는 총 %d대입니다." % (myCar1.speed, Car.count))

myCar2 = Car()
myCar2.speed = 60
print("자동차2의 현재 속도 %dKM, 생산된 자동차는 총 %d대입니다." % (myCar2.speed, Car.count))

-인스턴스 변수는 인스턴스에 공간이 생김

-클래스 변수는 클래스 안에 공간이생김

 

 

 

상속

class 서브클래스(슈퍼클래스)

 

Code12-07.py

# 클래스 선언 부분
class Car:
    speed = 0

    def upSpeed(self, value):
        self.speed += value
        
        print("현재 속도(슈퍼 클래스): %d" % self.speed)


class Sedan(Car):
    def upSpeed(self, value):
        self.speed += value
        
        if self.speed > 150:  # 속도 제한
            self.speed = 150

            print("현재 속도(서브 클래스): %d" % self.speed)


class Truck(Car):
    pass

# 변수 선언 부분
sedan1, truck1 = None, None

# 메인 코드 부분
truck1 = Truck()
sedan1 = Sedan()

print("트럭 --> ", end="")
truck1.upSpeed(200)  # 트럭의 속도를 200 증가

print("승용차 --> ", end="")
sedan1.upSpeed(200)  # 승용차의 속도를 200 증가 (제한 적용)

-매서드 오버라이딩:상위 클래스의 매서드를 서브 클래스에서 재정의

 

 

selfstudy12-2.py

# 클래스 선언 부분
class Car:
    speed = 0

    def upSpeed(self, value):
        self.speed += value
        print("현재 속도(슈퍼 클래스): %d" % self.speed)


class Sedan(Car):
    def upSpeed(self, value):
        self.speed += value
        if self.speed > 150:  # 속도 제한
            self.speed = 150
        print("현재 속도(서브 클래스): %d" % self.speed)


class Truck(Car):
    pass


class Sonata(Sedan):  # Sonata 클래스는 Sedan을 상속받음
    pass


# 변수 선언 부분
sedan1, truck1, sonata1 = None, None, None

# 메인 코드 부분
truck1 = Truck()
sedan1 = Sedan()
sonata1 = Sonata()

print("트럭 --> ", end="")
truck1.upSpeed(200)  # 트럭의 속도를 200 증가

print("승용차 --> ", end="")
sedan1.upSpeed(200)  # 승용차의 속도를 200 증가 (제한 적용)

print("소나타 --> ", end="")
sonata1.upSpeed(200)  # 소나타의 속도를 200 증가 (제한 적용)

 

Code12-08.py

import turtle
import random

# 슈퍼 클래스
class Shape:
    myTurtle = None
    cx, cy = 0, 0

    def __init__(self):
        self.myTurtle = turtle.Turtle('turtle')

    def setPen(self):
        r = random.random()
        g = random.random()
        b = random.random()
        self.myTurtle.pencolor((r, g, b))
        pSize = random.randrange(1, 10)
        self.myTurtle.pensize(pSize)

    def drawShape(self):
        pass


class Rectangle(Shape):
    width, height = [0] * 2

    def __init__(self, x, y):
        super().__init__()  # 부모 클래스 초기화
        self.cx = x
        self.cy = y
        self.width = random.randrange(20, 100)
        self.height = random.randrange(20, 100)

    def drawShape(self):
        sx1 = self.cx - self.width / 2
        sy1 = self.cy - self.height / 2
        sx2 = self.cx + self.width / 2
        sy2 = self.cy + self.height / 2

        self.setPen()  # 펜 설정
        self.myTurtle.penup()
        self.myTurtle.goto(sx1, sy1)  # 시작 위치 이동
        self.myTurtle.pendown()
        self.myTurtle.goto(sx1, sy2)  # 위쪽 변
        self.myTurtle.goto(sx2, sy2)  # 오른쪽 변
        self.myTurtle.goto(sx2, sy1)  # 아래쪽 변
        self.myTurtle.goto(sx1, sy1)  # 왼쪽 변


# 함수 선언 부분
def screenLeftClick(x, y):
    rect = Rectangle(x, y)  # 클릭한 좌표에 Rectangle 객체 생성
    rect.drawShape()        # 사각형 그리기


# 메인 코드 부분
turtle.title('거북이로 객체지향 사각형 그리기')
turtle.onscreenclick(screenLeftClick, 1)  # 왼쪽 클릭 이벤트 등록
turtle.done()

 

클래스의 특별한  메서드

Code12-09.py

##클래스 선언 부분##
class Line :
    length = 0
    def __init__(self, length) :
        self.length = length
        print(self.length, '길이의 선이 생성되었습니다.')

    # 소멸자
    def __del__(self):
        print(self.length, '길이의 선이 삭제되었습니다.')

    # 객체 표현 (출력 시 호출)
    def __repr__(self):
        return "선의 길이 : " + str(self.length)

    # 두 선 길이 더하기
    def __add__(self, other):
        return self.length + other.length

    # 두 선 비교 (길이가 작은 경우)
    def __lt__(self, other):
        return self.length < other.length

    # 두 선 비교 (길이가 같은 경우)
    def __eq__(self, other):
        return self.length == other.length


# 메인 코드
myLine1 = Line(100)
myLine2 = Line(200)

# 객체 출력
print(myLine1)

# 두 선의 길이 합
print('두 선의 길이 합:', myLine1 + myLine2)

# 두 선 비교
if myLine1 < myLine2:
    print('선분 2가 더 기네요.')
elif myLine1 == myLine2:
    print('두 선분이 같네요.')
else:
    print('모르겠네요.')

# 객체 삭제
del(myLine1)

# #100 길이의 선이 생성되었습니다.
# 200 길이의 선이 생성되었습니다.
# 선의 길이 : 100
# 두 선의 길이 합: 300
# 선분 2가 더 기네요.
# 100 길이의 선이 삭제되었습니다.
# 200 길이의 선이 삭제되었습니다. -> 얘는 우리 코드가 아닌 프로그램이 종료되면서 자동으로 생성됨

 

 

추상메서드

Code12-10.py

# 클래스 선언 부분
class SuperClass:
    def method(self):
        pass

class SubClass1(SuperClass):
    def method(self):       # 메서드 오버라이딩
        print('SubClass1에서 method()를 오버라이딩함')

class SubClass2(SuperClass):
    pass

# 메인 코드 부분
sub1 = SubClass1()
sub2 = SubClass2()

sub1.method()
sub2.method()

-메서드오버라이딩을 하려는데 슈퍼클래스는 빈 껍질로 만들고 서브를 오버라이딩 하려면 pass 사용하면 된다.

 

 

멀티 스레드

스레드: 프로그램 하나에서 여러 개를 동시에 처리할 수 있도록 제공하는 기능

 

Code12-11.py

import time

class RacingCar:
    def __init__(self, name):
        self.carName = name

    def runCar(self):
        for _ in range(3):
            carStr = self.carName + " ~ 달립니다.\n"
            print(carStr, end="")
            time.sleep(0.1)  # 0.1초 멈춤


# 메인 코드 부분
car1 = RacingCar("@자동차1")
car2 = RacingCar("#자동차2")
car3 = RacingCar("$자동차3")

car1.runCar()
car2.runCar()
car3.runCar()

 

 

Code12-12.py

import threading
import time

class RacingCar:
    def __init__(self, name):
        self.carName = name

    def runCar(self):
        for _ in range(3):
            carStr = self.carName + " ~ 달립니다.\n"
            print(carStr, end="")
            time.sleep(0.1)  # 0.1초 멈춤

# 메인 코드 부분
car1 = RacingCar("@자동차1")
car2 = RacingCar("#자동차2")
car3 = RacingCar("$자동차3")

th1 = threading.Thread(target = car1.runCar)
th2 = threading.Thread(target = car2.runCar)
th3 = threading.Thread(target = car3.runCar)

th1.start()
th2.start()
th3.start()

 

멀티 프로세싱:동시에 여러 cpu 사용

Code12-13.py

import multiprocessing
import time

#클래서 선언
class RacingCar:
    def __init__(self, name):
        self.carName = name

    def runCar(self):
        for _ in range(3):
            carStr = self.carName + " ~ 달립니다.\n"
            print(carStr, end="")
            time.sleep(0.1)  # 0.1초 멈춤

# 메인 코드 부분
if __name__ == "__main__":
    car1 = RacingCar("@자동차1")
    car2 = RacingCar("#자동차2")
    car3 = RacingCar("$자동차3")

    mp1 = multiprocessing.Process(target = car1.runCar)
    mp2 = multiprocessing.Process(target = car2.runCar)
    mp3 = multiprocessing.Process(target = car3.runCar)

    mp1.start()
    mp2.start()
    mp3.start()

    mp1.join() # 기다린다
    mp2.join()
    mp3.join()

 

selfstudy12-3.py

import threading

# 합 계산을 위한 클래스 정의
class SumCalculator:
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.result = 0

    def calculate_sum(self):
        self.result = sum(range(self.start, self.end + 1))
        print(f"Sum of {self.start} to {self.end}: {self.result}")

# 메인 코드 부분
calc1 = SumCalculator(1, 1000)
calc2 = SumCalculator(1, 100000)
calc3 = SumCalculator(1, 10000000)

# 각 계산을 별도의 스레드로 실행
th1 = threading.Thread(target=calc1.calculate_sum)
th2 = threading.Thread(target=calc2.calculate_sum)
th3 = threading.Thread(target=calc3.calculate_sum)

# 스레드 시작
th1.start()
th2.start()
th3.start()

# 모든 스레드가 끝날 때까지 대기
th1.join()
th2.join()
th3.join()

print("모든 계산이 완료되었습니다.")