7-1. 클래스

１.    클래스

(1)     똑같은 무엇인가를 계속해서 만들어 낼 수 있는 설계 도면

(2)     클래스는 새로운 이름 공간을 지원하는 단위, 모듈의 멤버

(3)     목적: OOP기법 구사, 자원의 재활용

(4)     클래스내의 멤버: 변수, 메소드, 생성자로 구성

(5)     접근지정자 無, 메소드 오버로딩 無

(6)     오버라이딩 有

(7) 클래스를 불러 쓰는 방법 2가지: has a관계(포함), is a 관계   

▶형식
class 클래스명:

１)       원형클래스 – prototype

２)       스스로 객체 생성

 

２.    객체(Object)

１)       클래스로 만든 피조물

２)       특징

①        객체마다 고유한 성격을 가짐

②        각각의 객체에 서로 영향을 안 줌

③        클래스로 만든 객체의 객체변수는 다른 객체의 객체변수에 상관없이 독립적인 값을 유지한다.
ex) a.first = 9로 변경해도 b.first는 변경되지 않고 그대로 3을 유지한다.

             => 각각 주소가 다른 곳에 값이 저장되기 때문

 

(2)     인스턴스: 클래스로 만든 객체

ex) a = Cookie()

a는 객체, a는 Cookie클래스의 인스턴스

class FourCal:
    def __init__(self, first, second):
        self.first = first
        self.second = second
        
a = FourCal(4, 2)
b = FourCal(3, 5)

print(id(a.first))
print(id(b.first))
print(id(a.second))
print(id(b.second))​

실행결과

 

３.    메서드(method)

(1)     클래스 안에서 구현된 함수

 

(2)     생성자(Constructor)

１)       객체가 생성될 때 자동으로 호출되는 메서드 - callback

２)       형식
def __init__(self, [매개변수..]):
    수행할 문장….
    self.매개변수|함수명….

３)       객체에 초기 값을 설정해야 할 필요가 있을 때도 사용

 

(3)     소멸자

１)       객체가 소멸될 때 자동으로 호출되는 메서드 – callback

２)       형식
def __del__(self, [매개변수..]):
    수행할 문장….
    self.매개변수|함수명….

３)       c언언 기반이라서 존재하지만 따로 사용하지는 않는다.

        => 자바처럼 일정시간 지나면 자동 삭제됨.

 

(4)     self

１)       메서드의 첫 번째 매개변수로 명시적으로 구현하는 키워드

２)       객체를 호출할 때 호출한 객체 자신이 전달될 때 받는 역할

３)       각각의 객체의 주소를 받는 것

４)       오버로딩 불가

５)       self말고 다른 이름을 사용해도 되지만 관례적으로 self를 사용

６)       클래스 내에서 정의된 메소드 내에서 클래스 수준의 메소드나 변수를 호출할 때는 반드시 앞에 self. 을 붙여줘야 한다.

７)       안 붙이면 해당 영역의 지역변수나 메소드를 호출하는 것이 된다.

 

ex1)

class TestClass: #원형클래스 - prototype: 스스로 객체 생성, 써주면 자동으로 만들어짐
    abc = 1 #멤버변수, 전역변수임
    
    #클래스의 메소드에만 self를 준다. 함수에는 안준다.
    # 생성자, 소멸자는 자동 호출. callback
    def __init__(self):
        print('생성자') #self: 자바의 this 같은 느낌
        
    def __del__(self):
        print('소멸자') 
        #자바: 가비지 컬렉터에서 일정시간 지나면 지워짐, 그래서 소멸자는 없지만 c언어 기반의 파이썬은 소멸자 존재
        #그러나 잘 사용하지 않음. 자바처럼 일정시간 지나면 저절로 지원짐
        
    def printMsg(self):
        name = '홍길동' #메소드의 지역변수
        print(name)
        #클래스의 멤버를 호출할 때는 self를 붙여서 호출
        print(self.abc) #클래스의 멤버를 부른다는 뜻으로 꼭 self를 표시해줘야함
        self.show() 
        
    def show(self):
        print('show')​

     ex2)

kor = 100

def abc():
    print('모듈의 멤버 함수')

class MyClass:
    kor = 88
    def __init__(self):
        pass
    
    def abc(self):
        print('클래스 멤버 메소드임을 선언하노라')
    
    def showData(self):
        #kor = 77
        print(kor)
        print(self.kor) # 클래스 내의 변수가 없으면 error남
        # self라고 쓰면 무조건 클래스의 전역변수 찾아감. 안쓰면 해당 메소드 내의 지역변수를 먼저 찾음. 77, 
        #지역변수가 없으면 클래스내의 전역변수가 아니라 모듈 전체의 전역변수를 찾으러 감
        self.abc() # 현재 클래스 내의 메소드를 call
        abc() # 현재 클래스 밖의 모듈의 함수 call​

 

４.    호출

(1)     클래스 이름으로 바로 호출

１)       형식: 객체변수명 = 클래스명()

①        클래스명.멤버변수명

②        클래스명.메소드명(객체변수명,[매개변수..])

２)       메소드를 호출할 때 self가 받을 수 있게 반드시 객체변수를 전달해줘야 한다. 아니면 오류 발생

 

(2)     객체변수로 호출

１)       형식: 객체변수명 = 클래스명()

①        객체변수명.멤버변수명

②        객체변수명.메소드명([매개변수])

# class : OOP기법 구사
# 클래스는 새로운 이름 공간을 지원하는 단위, 모듈의 멤버
# 클래스내의 멤버: 변수, 메소드, 생성자로 구성
# 접근지정자 無, 메소드 오버로딩 無
# 오버라이딩 有

print('이런저런 작업을 하다가 클레스 등장...')

class TestClass: #원형클래스 - prototype: 스스로 객체 생성, 써주면 자동으로 만들어짐
    abc = 1 #멤버변수, 전역변수임
    
    #클래스의 메소드에만 self를 준다. 함수에는 안준다.
    # 생성자, 소멸자는 자동 호출. callback
    def __init__(self):
        print('생성자') #self: 자바의 this 같은 느낌
        
    def __del__(self):
        print('소멸자') 
        #자바: 가비지 컬렉터에서 일정시간 지나면 지워짐, 그래서 소멸자는 없지만 c언어 기반의 파이썬은 소멸자 존재
        #그러나 잘 사용하지 않음. 자바처럼 일정시간 지나면 저절로 지원짐
        
    def printMsg(self):
        name = '홍길동' #메소드의 지역변수
        print(name)
        #클래스의 멤버를 호출할 때는 self를 붙여서 호출
        print(self.abc) #클래스의 멤버를 부른다는 뜻으로 꼭 self를 표시해줘야함
        self.show() 
        
    def show(self):
        print('show')

#원형클래스의 멤버변수를 바로 호출 - 실제로는 클래스이름으로 바로 호출하지는 않는다. 
#객체를 만들어서 사용. 메소드부르는것부터 문제가 생김        
print(TestClass.abc)
print()
#원형클래스의 메소드를 바로 호출 - self에서 에러남    
#TestClass.printMsg(self)

#객체변수 test를 사용
test = TestClass() #생성자 호출된 후 객체 생성(instance) - test변수가 주소를 기억함
print(test.abc)
test.printMsg() #printMsg(test)인데 생략. - Bound method call
#test.printMsg()에서 self는 test를 의미함. test가 가진 주소가 self에 대입되는 것
print('=====')

#원형클래스로 부르면서 객체변수를 매개변수로 사용해서 호출 가능
TestClass.printMsg(test) # unbound method call

#클래스의 타입 확인
print('클래스 타입확인: ', type(1))
print('클래스 타입확인: ', type(test))
print(id(test))
print(id(TestClass))​

실행결과

 

２)       객체변수 작동 원리

 

３)       호출 시 매개변수 대응관계

 

클래스 예제1)

#클래스

class Car: # int, float type처럼 Car라는 type을 만드는 것과 같음. car가 가져야할 특성들을 정의한 것 = 설계도
    handle = 0 #멤버변수(필드), 클래스내의 전역변수
    speed = 0
    
    def __init__(self, name, speed): #생성자 오버로딩 無 = 생성자를 여러개 생성 불가
        # 원형클래스에는 name에는 없고 각각의 객체들에만 만들어지는 color같이 튜닝하는 것과 같은 느낌
        self.name = name
        self.speed = speed
        # speed = speed 는 지역변수를 의미
        
    def showData(self): #self: 각각의 객체의 주소를 받는 것
        km = '킬로미터' #지역변수
        msg = '속도: '+str(self.speed) + km 
        #speed는 클래스 전역변수라서 self를 붙이고 km는 해당 메소드의 지역변수라서 self안씀
        return msg

print('car1---------------------------------------------')
car1 = Car('tom', 10) #car1 = Car라고 쓰면 Car의 주소를 참조하게 됨. 지금은 생성자 호출이 필요
print(car1.handle,car1.name, car1.speed)

car1.color = '핑크' #car1에 color가 추가 됨
print('car1.color: ', car1.color)

print('car2---------------------------------------------')
car2 = Car('james', 30)
print(car2.handle,car2.name, car2.speed)

print(car1.__dict__) #메소드가 아니라 속성이라서 보임
print(car2.__dict__)

print('method------------------------------------')
print('car1: ',car1.showData())
print('car2: ',car2.showData())

car1.speed = 100
car2.speed = 200
print('car1: ',car1.showData())
print('car2: ',car2.showData())
print()

print(Car.speed)
print(car1.speed)
print(car2.speed)

#print(Car.color) AttributeError: type object 'Car' has no attribute 'color'
print(car1.color)
#print(car2.color) AttributeError: 'Car' object has no attribute 'color'​

실행결과

 

Car 클래스 관계 설명)

 

클래스 예제2) 외부 클래스 호출

<test19handle 모듈>
# 움직이는 기계에 사용할 부품 클래스로 핸들만듬

class PohamHandle:
    quantity = 0 #회전량
    
    def LeftTurn(self, quantity):
        self.quantity = quantity
        return '좌회전'
    
    def RightTurn(self, quantity):
        self.quantity = quantity
        return '우회전'​

# car클래스 : 여러개의 부품클래스들을 조립해서 완성차를 생성
from pack2.test19handle import PohamHandle

class PohamCar:
    speed = 0
    turnShow = '정지'
    
    def __init__(self, ownerName):
        self.ownerName = ownerName
        self.handle = PohamHandle() #클래스의 포함관계. 포함관계는 .이 두 개이상 나옴
        
    def TurnHandle(self, q): # PohamCar메소드로 핸들을 움직이는 행위
        if q > 0:
            self.turnShow = self.handle.RightTurn(q)
        elif q < 0:
            self.turnShow = self.handle.LeftTurn(q)
        elif q == 0:
            self.turnShow = '직진' 

if __name__ =='__main__':
    tom = PohamCar('톰') #self = tom, ownerName = 톰
    tom.TurnHandle(10)
    print(tom.ownerName + '의 회전량은 ' + tom.turnShow + str(tom.handle.quantity))
    tom.TurnHandle(0)
    print(tom.ownerName + '의 회전량은 ' + tom.turnShow)
    print()
    
    oscar = PohamCar('오스카')
    oscar.TurnHandle(-5)
    print(oscar.ownerName + '의 회전량은 ' + oscar.turnShow + str(oscar.handle.quantity))​

실행결과