객체 지향 프로그래밍 언어 (OOP, Object Oriented Programming)

클래스 (Class)

• 설계도 (붕어빵 틀)

인스턴스 (Instance)

• 실제 구현체 (붕어빵)

축구 선수 정보를 Class로 구현

# class : class 예약어
# SoccerPlayer : class 이름
# object : 상속받는 객체명 (python3에서는 자동 상속)


class SoccerPlayer(object):

    # Attribute 추가 : __init__ & self
    # __init__ : 객체 초기화 예약 함수
    def __init__(self, name : str , position : str, back_number : int):

        # 객체 초기 정보 선언
        self.name = name
        self.position = position
        self.back_number = back_number
    
    # __는 특수한 예약 함수나 변수 그리고 함수명 변경(맨글링)으로 사용
    # EX : __main__, __add__, __str__, __eq__
    def __str__(self):
    
       return '안녕하세요, 저의 이름은 %s 입니다 , 그리고 저는 %s 으로 활약합니다' % (self.name, self.position)
        
    def change_position(self, new_postition):

        print('선수의 포지션을 변경합니다 : From %s to %s' % (self.position, new_postition))
        self.position = new_postition
        
    def change_back_number(self, new_back_number):

        print('선수의 번호를 변경합니다 : From %d to %d' % (self.back_number, new_back_number))
        self.back_number = new_back_number

Instance 생성

namwoo = SoccerPlayer('namwoo', 'MF', 12)
print(namwoo)

# output : 안녕하세요, 저의 이름은 namwoo 입니다 , 그리고 저는 MF 으로 활약합니다

선수 정보 변경

포지션 변경

namwoo.change_position('FW')
# output : 선수의 포지션을 변경합니다 : From MF to FW

번호 변경

namwoo.change_back_number(10)
# output : 선수의 번호를 변경합니다 : From 12 to 10

Inheritance (상속)

• 부모 클래스로부터 속성과 Method를 물려받은 자식 클래스를 선언

class Korean_SoccerPlayer(SoccerPlayer):
	
    def __init__(self, name : str , position : str, back_number : int, nationality : str, team : str):
    	
        # 부모 객체 사용
        super().__init__(self, name : str , position : str, back_number : int)
        self.nationality = nationality # 속성값 추가
        self.team = team
	
    # 새로운 매서드 추가
	def do_work(self):

        print('%s 에서 경기를 뜁니다' % (self.team))
        
    def change_position(self):
    
    	super().change_position() # 부모 클래스 함수 사용
        print('%s 에서 %s 역할로 변경합니다' % (self.team, self.position))

Polymorphism (다형성)

• 같은 이름 메소드의 내부 로직을 다르게 작성
• Dynamic Typiing 특성으로 인해 파이썬에서는 같은 부모 클래스의 상속에서 주로 발생함

class Animal:

    def __init__(self, name):
        self.name = name
    
    def takl(self):
        raise NotimplementedError('Subclass must implement abstract method')

class Cat(Animal):
    def talk(self):
        return 'Meow'

class Dog(Animal):
    def talk(self):
        return 'Woof'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print(animal.name + ': ' + animal.talk())

Visibility (가시성)

• 객체의 정보를 볼 수 있는 레벨을 조절하는 것
• 누구나 객체 안에 모든 변수를 모두 볼 필요가 없음

class Product(object):
    pass

class Inventory(object):
    
    def __init__(self):
        
        # Private 변수로 선언 타객체가 접근 못함
        self.__items = []
        self.test = 'test_product'
        
    def add_new__item(self, product):
        
        if type(product) == Product:
            self.__items.append(product)
            print('new item added')
        
        else:
            raise ValueError('invalid Item')
            
    def get_number_of_items(self):
        
        return len(self.__items)

    @property # property decorator 숨겨진 변수를 반환하게 해줌
    def items(self):
        return self.__items

First-class objects

• 일등 함수 또는 일급 객체
• 변수나 데이터 구조에 할당이 가능한 객체
• 파라메터로 전달이 가능 + 리턴 값으로 사용
• 파이썬 함수는 일급 함수

def square(x):
	return x * x

def cube(x):
	return x * x * x

# 함수를 파라메터로 사용
def formula(method, argument_list):
	return [method(value) for value in argument_list]

Inner Fuction

• 함수 내에 또 다른 함수가 존재

def print_msg(msg):
	
    def printer():
    	print(msg)
    printer()

print_msg('hello Python')

# output : hello Python 

Closures : Inner Function을 return 값으로 반환

def tag_func(tag, text):
    
    text = text
    tag = tag
    
    def inner_func():
        
        return '<{0}>{1}<{0}>'.format(tag, text)
    
    return inner_func

h1_func = tag_func('title', 'This is Python class')
p_func = tag_func('p', 'Data Academy')

Decorator Function

def star(func):
    
    def inner(*args, **kwargs):
        print('*' * 30)
        func(*args, **kwargs)
        print('*' * 30)
    
    return inner

@star
def printer(msg):
    print(msg)
printer('hello')