클래스(class)

• 변수와 함수를 묶어놓은 개념
• 클래스는 객체(데이터와 기능을 갖고있는..)를 만들기 위한 설계도
• 클래스를 메모리에 객체화 하면 그걸 인스턴스(instance) 라고한다.

클래스의 구조

• 변수: 인스턴스(객체화되면 사용가능한 변수) 클래스 변수가 있다.
• 함수:메소드(객체의 소속되어있는 함수)
• init메소드:생성자
  • 객체의 초기화를 담당, 객체의 변수의 값을 초기 설정
  • 갠체화가 되었을때 생성해야하거나 초기값을 세팅해야하는 인스턴스 변수들이 있다면 __init__메소드 안에 선언(정의) 하면 된다.

클래스를 정의하는 방법

class (ClassName): #pascal case, upper camel case
    def__init__(self):
        code context
        ...
    def<method_name>(self):
        code context
        ...

class PlayerCharactre:
    def __init__(self,hp,exp):
        self.hp = hp
        self.exp =exp

Player1 = PlayerCharactre(100,0)
Player2 = PlayerCharactre(200,50)

Player1.hp , Player1.exp , Player2.hp , Player2.exp
	   출력
(100, 0, 200, 50)

• self
• 클래스가 객체화 되었을때 자기 자신의 주소를 받는 파라미터
• 클래스가 인스턴스화 되면 메모리상에서 어디에 있는지 self 파라미터의 주소값을 참조해서 객체의 변수의 접근하다.

class MyClass:
    def __init__(self):
        print(id(self))

mc = MyClass()
	  출력
140525070718288

id(mc)
	  출력
140525070718288

class PlayerCharactre:
    def __init__(self,exp):
        self.exp = exp    
    def attack(self):
        print("공격하기")
        self.exp += 2
        
    def set_exp(slef,exp):
        self.exp = exp

player = PlayerCharactre(10)

player.attack()
player.exp

  출력

공격하기
12

• 클래스를 정의할때 __init__ 를 무조건 정의하자
• 객체화 되었을때 사용할 변수들을 이안에 정의해주자.
• 클래스 안에 메소그(__init__포함)들을 정의할떄는 무조건 펏번째 파라미터로 self를 작성해주자
• 클래스가 객체화되서 해당 객체의 메소드를 실행할때는 self 는 자동으로 파이썬이 넣어줌

class PlayerCharacter:
    def __init__ (self,hp,exp): # 객체화 되면 자동으로 실행됨
        self.hp = hp # 인스터스 변수 선언됨
        self.exp = exp

    def attack(self): # 내가 위치한 인스턴스 위치에 접근하기 위해 self 받는 것이다.
        print('공격하기')
        self.exp += 2 # 인스턴스 변수에 접근 하려면 self 를 참조해야한다.

    def defend(self):
        print('방어하기')
        self.exp += 1
    
    def attacked(self,attack_size):
        print('공격 받음')
        self.hp = self,attack_size       

player1 = PlayerCharacter(100,0)
player2 = PlayerCharacter(120,10)


player1.attack()
player1.defend()
player1.attacked(3)

  출력

공격하기
방어하기
공격 받음

class 변수

class PlayerCharacter:
    character = 'Wizard'
    def __init__(self,hp=100,exp=0):
        self.hp = hp
        self.exp = exp


PlayerCharacter.character # 클래스 변수는 객체화 되지 않아도 참조 가능! 
  
  출력

'Wizard'

• 클래스 메소드
  -- 객체화 하지 않아도 사용 가능한 메소드

class PlayerCharacter:
    character_type = "Wizard"

    @classmethod
    def print_character_type(cls): # 클래스의 주소를 받는 첫번째 파라미터를 cls 라고한다.
        print(cls.character_type)
        
PlayerCharacter.print_character_type()

  출력
Wizard

class car:
    car_type = 'morning'
    def __init__(self,name,color,num):
        self. name = name
        self. color = color
        self. num = num

j = car('morning','blue','1343')
print(j.name)
print(j.color)
print(j.num)

  출력
morning
blue
1343

상속

• 구현된 클래스의 기능(메소드)을 그대로 가져다가 사용하거나(추가, 수정 ) 할때 사용하는 개념
• 부모 클래스의 속성과(인스턴스변수와 메소드)들을 자식클래스가 그대로 물려받는 개념
  -확장개념, 부모클래스와 자식클래스가 합쳐지는 개념

class PlayerCharacter:
    def __init__(self, hp=100, exp=0):
        print(f'부모의 주소값: {id(self)}')
        self.hp = hp
        self.exp = exp

    def attack(self):
        print("공격")
        self.exp += 2

    def defend(self):
        print("방어")
        self.exp += 1 

class Wizard(PlayerCharacter): # 상속받기
    def __init__(self,mp):
        print(f'자식의 주소값: {id(self)}')
        self.mp = mp
        super().__init__() # 부모 클래스의 생성자를 실행하겠다.
    
    def magic_skill(self):
        self.mp -= 2     

Wizard(30)
자식의 주소값: 139664554494736
부모의 주소값: 139664554494736

오버라이딩(Overriding)

• 부모로부터 받는 메소드를 수정하고 싶을때 시작 클래스에 정의한다.

class PlayerCharacter:
    def __init__(self, hp=100, exp=0):
        self.hp = hp
        self.exp = exp
        
    def attack(self):
        print("공격")
        self.exp += 2

    def defend(self):
        print("방어")
        self.exp += 1 

class Wizard(PlayerCharacter): # 상속받기
    def __init__(self,mp):
        
        self.mp = mp
        super().__init__() # 부모 클래스의 생성자를 실행하겠다.
    
    def magic_skill(self):
        print("마공")
        self.mp -= 2 

    def defend(self):
        print("방막")
        self.hp -= 3 
    
    def attack(self):
        print("공격")
        self.exp += 10

player = Wizard(20)
print(player.hp)
print(player.exp)
player.hp
player.exp
player.attack()
player.attack()
player.defend()
print(player.exp)

자식의 주소값: 139664553275920
부모의 주소값: 139664553275920
100
0
공격
공격
방어
5

class Calculator:
    def __init__(self,num=0):
        self.num = num
    def add(self,num): # 한개의 정수를 입력 받아 self.num 더하기, 반환값 X
        pass
    def sub(self,num): # 한개의 정수를 입력 받아 self.num 빼기, 반환값 X
        pass
    def mul(self,num): # 한개의 정수를 입력 받아 self.num 곱하기, 반환값 X
        pass
    def div(self,num): # 한개의 정수를 입력 받아 self.num 나누기, 반환값 X
        pass
    def result(self):
        return self.num
    def reset(self):
        self.num = 0

class yang(Calculator):
    def __init__(self, num = 0):
        self.num = num
        if num != int: 
            print('입렵값이 정수가 아닙니다. 입력값을 0으로 변경합니다')
    
    def add(self,num): 
        self.result = self.result + num
    
    def sub(self,num): 
        self.result -= num
    
    def mul(self,num): 
        self.num *= num
    
    def div(self,num): 
        self.result /= num
    
    def result(self):
        return self.num
    
    def reset(self):
        self.num = 0
        return self.num         

c = yang(10)

입렵값이 정수가 아닙니다. 입력값을 0으로 변경합니다

c.result()

출력
10

getter & setter

• 인스턴스 번수에 접근할때 특정 로직을 거쳐서 접근시키는 방법
• getter & setter 정의할 이스턴스 변수는private하자

class Wizard(PlayerCharacter):   # 참고용
    def __init__(self,mp):
        super().__init__()
        self.mp = mp
    # getter 세팅할때는 다음의 데코레이터 정의
    @property
    def mp(self):
        print("gettre동작")
        return self.__mp
    # setter 세팅할떄는 getter 의 메소드명.setter
    @mp.setter
    def mp(self,mp):
        print("settr동작")
        if mp < 0:
            mp = 0

        self.__mp = mp     

player = Wizard(5)
settr동작
player.mp
gettre동작

매직 메소드

• 메소드 명이 두개의 언더바로 감싸져 있다.
• 파이썬의 다양한 내장함수들이 클래스의 매직 메소드들을 호출하여 결과를 만들어 낸다.

class MyDataset:
    def __init__(self,data):
        self.data = data

    def __call__(self):
        print("함수 호출 방법처럼 객체를 함수 호출하듯이 만들어주는 메소드")

    def __str__(self): #print() 함수에 이 클래스의 객체를 넣을경우 이 메소드에 리턴값을 출력
        return "My dataset Class"

    def __len__(self): # len() 내장함수는 객체의 이 매직메소드를 호출
        return len(self.data)

    def __getitem__(self,idx): # 인덱싱과 슬라이싱을 가능하게 한다.
        return self.data[idx]                

data = list(range(50,100))
dt = MyDataset(data)
dt

dt()
함수 호출 방법처럼 객체를 함수 호출하듯이 만들어주는 메소드
print(dt)
My dataset Class
len(dt)
50
dt[:6]
[50, 51, 52, 53, 54, 55]