Object-Oriented Programming

속성(variable)과 행동(method)의 개념을 가진 객체 지향 프로그래밍

• OOP는 설계도에 해당하는 클래스(class)와 실제 구현체인 인스턴스(instance)로 나뉜다.

---

Objects in Python

축수 선수 정보를 class로 구현

• class 선언

class SoccerPlayer(object):
# class: 예약어
# SoccerPlayer: class 이름
# object: 상속받는 객체명

class SoccerPlayer(object):
    def __init__(self, name, position, back_number):
        self.name = name
        self.position = position
        self.back_number = back_number
        
    def change_back_number(self, new_number):
        print("선수의 등번호를 변경합니다 : From %d to %d" % (self.back_number, new_number))
        self.back_number = new_number
        
jinhyun = SoccerPlayer("Jinhyun", "MF", 10)
print("현재 선수의 등번호는 :", jinhyun.back_number)
jinhyun.change_back_number(5)
print("현재 선수의 등번호는 :", jinhyun.back_number)

• 변수와 Class명 함수명은 짓는 방식이 존재한다.

  • snake_case : 띄워쓰기 부분에 “_” 를 추가
    뱀 처럼 늘여쓰기, 파이썬 함수/변수명에 사용한다.
  • CamelCase: 띄워쓰기 부분에 대문자
    낙타의 등 모양, 파이썬 Class명에 사용한다.
    
    

• Attribute 추가는 __init__, self를 사용한다. (__init__: 객체 초기화 예약 함수)

• __는 특수한 예약 함수나 변수 그리고 함수명 변경(맨글링)으로 사용한다.
  예) __main__ , __add__ , __str__ , __eq__

  • __str__: 객체를 print 할 때 실행되는 함수
  • __add__, __sub__: 객체끼리의 연산에 사용되는 함수

class SoccerPlayer(object):
    def __str__(self):
        return "Hello, My name is %s. I play in %s in center " % \ (self.name, self.position)

jinhyun = SoccerPlayer("Jinhyun", "MF", 10)
print(jinhyun)

• method(Action) 추가는 기존 함수와 같지만, __self__를 추가해야만 class 함수로 인정된다.

• Object 이름 선언과 함께 초기값 입력 하기

jinhyun = SoccerPlayer("Jinhyun", "MF", 10)
# jinhyun: 객체명
# SoccerPlayer: class명
# ("Jinhyun", "MF", 10): \__init\__ 함수 Interface, 초기값

---

OOP Implementation Example

노트북

• Note를 정리하는 프로그램
• 사용자는 Note에 뭔가를 적을 수 있다.
• Note에는 Content가 있고, 내용을 제거할 수 있다.
• 두 개의 노트북을 합쳐 하나로 만들 수 있다.
• Note는 Notebook에 삽입된다.
• Notebook은 Note가 삽입 될 때 페이지를 생성하며, 최고 300페이지까지 저장 가능하다.
• 300 페이지가 넘으면 더 이상 노트를 삽입하지 못한다.

-	Notebook	Note
method	add_note, remove_note, get_number_of_pages	write_content, remove_all
variable	title, page_number, notes	content

class Note(object):
    def __init__(self, content = None):
        self.content = content
    
    def write_content(self, content):
        self.content = content

    def remove_all(self):
        self.content = ""

    def __add__(self, other):
        return self.content + other.content

    def __str__(self):
        return self.content
        
        
class NoteBook(object):
    def __init__(self, title):
        self.title = title
        self.page_number = 1
        self.notes = {}
        
    def add_note(self, note, page = 0):
        if self.page_number < 300:
            if page == 0:
                self.notes[self.page_number] = note
                self.page_number += 1
            else:
                self.notes = {page : note}
                self.page_number += 1
        else:
            print("Page가 모두 채워졌습니다.")

    def remove_note(self, page_number):
        if page_number in self.notes.keys():
            return self.notes.pop(page_number)
        else:
            print("해당 페이지는 존재하지 않습니다")

    def get_number_of_pages(self):
        return len(self.notes.keys())

---

OOP Characteristics

객체 지향 언어의 특징

Inheritance 상속

부모 class로 부터 속성과 Method를 물려받은 자식 class를 생성 하는 것

• self는 생성된 인스턴스인 자기 자신을 가리킨다.
• super()는 부모 객체를 가리킨다.

class Person(object): # 부모 클래스 Person 선언
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
        
    def about_me(self): # Method 선언
        print("저의 이름은 ", self.name, "이구요, 제 나이는 ", str(self.age), "살 입니다.")

class Employee(Person): # 부모 클래스 Person으로 부터 상속
    def __init__(self, name, age, gender, salary, hire_date):
        super().__init__(name, age, gender) # 부모객체 사용
        self.salary = salary
        self.hire_date = hire_date # 속성값 추가
        
    def do_work(self): # 새로운 메서드 추가
        print("열심히 일을 합니다.")

    def about_me(self): # 부모 클래스 함수 재정의
        super().about_me() # 부모 클래스 함수 사용
        print("제 급여는 ", self.salary, "원 이구요, 제 입사일은 ", self.hire_date, " 입니다.")

Polymorphism 다형성

같은 이름 메소드의 내부 로직을 다르게 작성

• Dynamic Typing 특성으로 인해 파이썬에서는 같은 부모클래스의 상속에서 주로 발생한다.

class Animal:
    def __init__(self, name): # Constructor of the class
        self.name = name
        
    def talk(self): # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

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

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

animals = [Cat('Missy'), Cat('Mr. Mistoffelees'), Dog('Lassie')]
for animal in animals:
    print(animal.name + ': ' + animal.talk())

Visibility 가시성

객체의 정보를 볼 수 있는 레벨을 조절하는 것

• 누구나 객체 안에 모든 변수를 볼 필요가 없다. (필요 없는 정보에는 접근 할 필요가 없다.)

• 캡슐화 또는 정보 은닉 (Information Hiding)
  • Class를 설계할 때, 클래스 간 간섭 / 정보공유를 최소화한다.
  • 심판 클래스가 축구선수 클래스 가족 정보를 알 필요가 없다.
  • 캡슐을 던지듯, 인터페이스만 알아서 써야한다.

• Example
  1. Product 객체를 Inventory 객체에 추가
  2. Inventory에는 오직 Product 객체만 들어감
  3. Inventory에 Product가 몇 개인지 확인이 필요
  4. Inventory에 Product items는 직접 접근이 불가

class Product(object):
    pass
    
class Inventory(object):
    def __init__(self):
        self.__items = []

    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)

my_inventory = Inventory()
my_inventory.add_new_item(Product())
my_inventory.add_new_item(Product())
print(my_inventory.get_number_of_items())

print(my_inventory.__items) # 접근할 수 없다.
my_inventory.add_new_item(object)

• Example
  1. Product 객체를 Inventory 객체에 추가
  2. Inventory에는 오직 Product 객체만 들어감
  3. Inventory에 Product가 몇 개인지 확인이 필요
  4. Inventory에 Product items 접근 허용

class Product(object):
    pass

class Inventory(object):
    def __init__(self):
        self.__items = []

    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
    def items(self):
        return self.__items
    
my_inventory = Inventory()
my_inventory.add_new_item(Product())
my_inventory.add_new_item(Product())
print(my_inventory.get_number_of_items())
items = my_inventory.items
items.append(Product())
print(my_inventory.get_number_of_items())

---

decorate

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks
        # self.gotmarks = self.name + ' obtained ' + self.marks + ' marks'
    @property
    def gotmarks(self):
        return self.name + ' obtained ' + self.marks + ' marks'

• decorate를 이해하기 위한 개념

1. First-class objects
   1) 일등함수 또는 일급 객체
   2) 변수나 데이터 구조에 할당이 가능한 객체
   3) 파라메터로 전달이 가능 + 리턴 값으로 사용
   -> 파이썬의 함수는 일급함수이다.

def square(x):
    return x * x
    
f = square # 함수를 변수로 사용
f(5)


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]

2. inner function 함수 내에 또 다른 함수가 존재

def print_msg(msg):
    def printer():
        print(msg)
    printer()
    
print_msg("Hello, Python")

• closures : inner function을 return값으로 반환

def print_msg(msg):
    def printer():
        print(msg)
    return printer
    
another = print_msg("Hello, Python")
another()

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")

3. decorator function
   closures 복잡한 클로저 함수를 간단하게 하는 함수

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner
    
@star
def printer(msg):
    print(msg)
printer("Hello")

def star(func):
    def inner(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return inner
    
def percent(func):
    def inner(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return inner
    
@star
@percent
def printer(msg):
    print(msg)
printer("Hello")
# ******************************
# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# Hello
# %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
# ******************************

Module and Project

파이썬은 대부분의 라이브러리가 이미 다른 사용자에 의해서 구현되어 있다.

---

Module 모듈

작은 프로그램 조각들 (.py 파일을 의미)

• 모듈들을 모아서 하나의 큰 프로그램을 개발한다.

• 프로그램을 모듈화 시키면 다른 프로그램이 사용하기 쉽다.
  ex) 카카오톡 게임을 위한 카카오톡 접속 모듈

• Built-in Module인 Random을 사용해서 난수를 쉽게 생성할 수 있다.

• 같은 폴더에 Module에 해당하는 .py 파일과 사용하는 .py을 저장한 후 import 문을 사용해서 module을 호출한다.

namespace

모듈을 호출할 때 범위 정하는 방법

• 모듈 안에는 함수와 클래스 등이 존재 가능하다.
• 필요한 내용만 골라서 호출 할 수 있다.
• from 과 import 키워드를 사용한다.

1. Alias 설정 – 모듈명을 별칭으로 써서 사용한다

import fah_converter as fah # fah_converter를 fah라는 이름으로
print(fah.covert_c_to_f(41.6) # 모듈 안의 covert_c_to_f 함수를 쓴다.

2. 모듈에서 특정 함수 또는 클래스만 호출

from fah_converter import covert_c_to_f # covert_c_to_f 함수만 호출한다.
print(covert_c_to_f(41.6))

3. 모듈에서 모든 함수 또는 클래스를 호출

from fah_converter import * # 전체 호출
print(covert_c_to_f(41.6))

Built-in Modules

파이썬이 기본 제공하는 라이브러리

• 문자처리, 웹, 수학 등 다양한 모듈이 제공된다.
• 별다른 조치없이 import 문으로 활용 가능하다.

# 난수
import random
print (random.randint (0,100)) # 0~100사이의 정수 난수를 생성
print (random.random()) # 일반적인 난수 생성

# 시간
import time
print(time.localtime()) # 현재 시간 출력

# 웹
import urllib.request
response = urllib.request.urlopen("http://thetemlab.io")
print(response.read())

• 수 많은 파이썬 모듈의 사용 방법
  1) 구글 검색
  2) 모듈을 import 한 후 Help
  3) Python 공식 문서

---

Package 패키지

하나의 대형 프로젝트를 만드는 코드의 묶음

• 다양한 모듈들의 합, 폴더로 연결 된다.
• __init__ , __main__ 등 키워드 파일명이 사용된다.
• 다양한 오픈 소스들이 모두 패키지로 관리되고 있다.

Package 만들기

1. 기능들을 세부적으로 나눠 폴더로 만든다.

2. 각 폴더 별로 필요한 모듈을 구현한다.

# echo.py
def echo_play(echo_number):
    print ("echo {} number start".format(echo_number))

3. 1차 Test –python shell

mport echo
echo.echo_play(10)
# echo 10 number start

4. 폴더별로 __init__.py을 구성한다.
   • 현재 폴더가 패키지임을 알리는 초기화 스크립트
   • 없을 경우 패키지로 간주하지 않는다. (3.3+ 부터는 간주한다.)
   • 하위 폴더와 py 파일(모듈)을 모두 포함한다.
   • import와 all keyword를 사용한다.

__all__ = ['image', 'stage', 'sound']
from . import image
from . import stage
from . import sound

5. __main__.py 파일을 만든다.
   Package 내에서 다른 폴더의 모듈을 부를 때 호출하는 방법 (절대 참조, 상대 참조)

from game.graphic.render import render_test() # 절대 참조
from .render import render_test() # . 현재 디렉토리 기준
from ..sound.echo import echo_test() # .. 부모 디렉토리 기준

from stage.main import game_start
from stage.sub import set_stage_level
from image.character import show_character
from sound.bgm import bgm_play

if __name__ == '__main__':
    game_start()
    set_stage_level(5)
    bgm_play(10)
    show_character()

6. 실행 한다. – 패키지 이름만으로 호출한다.

---

Virtual Envitronment 가상환경

프로젝트 진행 시 필요한 패키지만 설치하는 환경

• 기본 인터프리터 + 프로젝트 종류별 패키지 설치
  ex) 웹 프로젝트, 데이터 분석 프로젝트 (각각 패키지 관리할 수 있는 기능)

• 다양한 패키지 관리 도구를 사용한다.

• 대표적인 도구 virtualenv와 conda가 있다.

  virtualenv + pop	conda
  가장 대표적인 가상환경 관리 도구	상용 가상환경도구, miniconda 기본 도구
  레퍼런스 + 패키지 개수	설치의 용이성, Windows에서 장점

conda 가상환경

conda create -n my_project python=3.8

   conda create: 가상환경 새로 만들기
   -n my_project: 가상환경 이름
   python=3.8: 파이썬 버전

• 가상환경 호출

conda activate my_project

• 가상환경 해제

conda deactivate

• 패키지 설치

conda install <패키지명>

• Windows에서는 conda / linux, mac에서는 conda or pip