객체 지향 프로그래밍

<instance.py>

# 전체 SoccerPlayer 코드
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

    def __str__(self):
        return "Hello, My name is %s. I play in %s in center." % (self.name, self.position)
    
# SoccerPlayer를 사용하는 instance 코드
hotari = SoccerPlayer("Hotari", "DF", 14)

print("현재 선수의 등번호는:", hotari.back_number)
hotari.change_back_number(5)
print("현재 선수의 등번호는:", hotari.back_number)
print(hotari)

<compile 결과>

 

<class.py>

# 데이터
names = ["Messi", "Ramos", "Son", "Park", "Buffon"]
positions = ["MF", "DF", "CF", "WF", "GK"]
numbers = [10, 4, 7, 13, 1]

# 이차원 리스트
players = [[name, position, number] for name, position, number in zip(names, positions, numbers)]
print(players)
print(players[0])

# 전체 SoccerPlayer 코드
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 ro %d" % (self.back_number, new_number))
        self.backnumber = new_number

    def __str__(self):
        return "Hello, My name is %s. I play in %s in center." % (self.name, self.position)
    
# 클래스 - 인스턴스
player_objects = [SoccerPlayer(name, position, number) for name, position, number in zip(names, positions, numbers)]
print(player_objects[0])
print(player_objects[1])
print(player_objects[2])
print(player_objects[3])
print(player_objects[4])

<compile 결과>

 

<notebook_program.py>

# Note 클래스 구현
class Note(object):
    def __init__(self, contents = None):
        self.contents = contents

    def write_contents(self, contents):
        self.contents = contents

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

    def __str__(self):
        return self.contents
    
# Notebook 클래스 구현
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("페이지가 모두 채워졌다.")
            
    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())
    
from notebook import Note
from notebook import NoteBook

good_sentence = """세상 사는 데 도움이 되는 명언, 힘이 되는 명언, 용기를 주는 명언, 
위로되는 명언, 좋은 명언 모음 100가지. 자주 보면 좋을 것 같아 선별했습니다."""
note_1 = Note(good_sentence)

good_sentence = """삶이 있는 한 희망은 있다. - 키케로"""
note_2 = Note(good_sentence)

good_sentence = """하루에 3시간을 걸으면 7년 후에 지구를 한 바퀴 돌 수 있다. - 새뮤얼 존슨"""
note_3 = Note(good_sentence)

good_sentence = """행복의 문이 하나 닫히면 다른 문이 열린다. 그러나 우리는 종종 닫힌 문을
멍하니 바라보다가 우리를 향해 열린 문을 보지 못하게 된다. - 헬렌 켈러"""
note_4 = Note(good_sentence)

wise_saying_notebook = NoteBook("명언 노트")
wise_saying_notebook.add_note(note_1)
wise_saying_notebook.add_note(note_2)
wise_saying_notebook.add_note(note_3)
wise_saying_notebook.add_note(note_4)

 

<inheritance1.py>

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

 

<inheritance2.py>

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, "입니다.")

 

<polymorphism1.py>

n_crawler = NaverCrawler()
d_crawler = DaumCrawler()
cralwers = [n_crawler, d_crawler]
news = []
for cralwer in cralwers:
    news.append(cralwer.do_crawling())

 

<polymorphism2.py>

class Animal:
    def __init__(self, name):
        self.name = name
    def talk(self):
        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())

<compile 결과>

 

<visibility1.py>

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)

    def __init__(self):
        self.__items = []   # private 변수로 선언 (타인이 접근 못 함)

    @property       # property 데코레이터 (숨겨진 변수 반환)
    def items(self):
        return self.__items
    
my_inventory = Inventory()
my_inventory.add_new_item(Product())
my_inventory.add_new_item(Product())

my_inventory.__items