5가지 클래스 설계의 원칙 (S.O.L.I.D)

# 나쁜 예
# 학생성적과 수강하는 코스를 한개의 class에서 다루는 예
# 한 클래스에서 두개의 책임을 갖기 때문에, 수정이 용이하지 않다.
class StudentScoreAndCourseManager(object):
    def __init__(self):
        scores = {}
        courses = {}
        
    def get_score(self, student_name, course):
        pass
    
    def get_courses(self, student_name):
        pass
    
# 변경 예
# 각각의 책임을 한개로 줄여서, 각각 수정이 다른 것에 영향을 미치지 않도록 함
class ScoreManager(object):
    def __init__(self):
        scores = {}
        
    def get_score(self, student_name, course):
        pass
    
    
class CourseManager(object):
    def __init__(self):
        courses = {}
    
    def get_courses(self, student_name):
        pass

from urllib.request import urlopen
from bs4 import BeautifulSoup
import re

title_list = list()
hit_count_list = list()

for pageNum in range(1):
    html = urlopen("https://www.seeko.co.kr/zboard4/zboard.php?id=mainnews&page=" + str(pageNum + 1) + "&select_arrange=headnum&desc=asc&category=&sn=off&ss=on&sc=off&keyword=&sn1=&divpage=10")
    html_object = BeautifulSoup(html, "html.parser")
    title_data = html_object.findAll("td", {"class": "article_subject"})
    title_hit = html_object.findAll("td", {"class": "article_count"})
    for title_wrap in title_data:
        print(title_wrap.get_text())
        title_list.append(title_wrap.get_text())
    for title_hit in title_hit:
        hit_count_list.append(title_hit.get_text())

import xlsxwriter

workbook = xlsxwriter.Workbook('ITArticleReport.xlsx')
worksheet = workbook.add_worksheet()

worksheet.set_column(0, 0, 5)
worksheet.set_column(1, 1, 80)

cell_format = workbook.add_format({'bold': True, 'align': 'center', 'fg_color': '#01579B', 'color': 'white', 'border': 1})
worksheet.write(1, 1, '타이틀', cell_format)
worksheet.write(1, 2, '클릭수', cell_format)

cell_format_gray = workbook.add_format({'fg_color': '#ECEFF1', 'border': 1})
cell_format_white = workbook.add_format({'fg_color': 'white', 'border': 1})

for num in range(len(title_list)):
    worksheet.write(num + 2, 1, title_list[num], cell_format_gray)
    worksheet.write(num + 2, 2, hit_count_list[num], cell_format_gray)

workbook.close()

# 나쁜 예
class Rectangle(object):
    def __init__(self, width, height):
        self.width = width
        self.height = height
        
class Circle:
    def __init__(self, radius):
        self.radius = radius

class AreaCalculator(object):
    def __init__(self, shapes):
        self.shapes = shapes

    def total_area(self):
        total = 0
        for shape in self.shapes:
            total += shape.width * shape.height
        return total

shapes = [Rectangle(2, 3), Rectangle(1, 6)]
calculator = AreaCalculator(shapes)
print("The total area is: ", calculator.total_area())

# 좋은 예
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height
    
class Circle:
    def __init__(self, radius):
        self.radius = radius
        
    def area(self):
        return 3.14 * self.radius ** 2
    
    
'''다른 도형에 대해 확장하기 위해서,
AreaCalculator는 수정이 필요 없음 (변경에 닫혀 있음)
단지, Shape을 상속받은 다른 class를 정의하기만 하면 됨 (확장에 대해 개방됨)
'''
class AreaCalculator(object):
    def __init__(self, shapes):
        self.shapes = shapes

    def total_area(self):
        total = 0
        for shape in self.shapes:
            total += shape.area()
        return total


shapes = [Rectangle(1, 6), Rectangle(2, 3), Circle(5), Circle(7)]
calculator = AreaCalculator(shapes)

print("The total area is: ", calculator.total_area())

# 추상 클래스 선언하기
from abc import *

class Character(metaclass=ABCMeta):
    def __init__(self, name='yourname', health_point=100, striking_power=3, defensive_power=3):
        self.name = name
        self.health_point = health_point
        self.striking_power = striking_power
        self.defensive_power = defensive_power        
    
    def get_info(self):
        print (self.name, self.health_point, self.striking_power, self.defensive_power)
    
    @abstractmethod
    def attack(self, second):
        pass

    @abstractmethod
    def receive(self):
        pass

    @abstractmethod
    def special(self):
        pass

# 추상 클래스 선언하기
from abc import *

class Character(metaclass=ABCMeta):
    @abstractmethod
    def attack(self):
        pass
    
    @abstractmethod
    def move(self):
        pass

    @abstractmethod
    def eat(self):
        pass

class MyClass:
    pass

from abc import *

class Character(metaclass=ABCMeta):
    @abstractmethod
    def attack(self):
        pass

# 나쁜 예
# 추상 클래스 상속하기
class Elf(Character):
    def attack(self):
        print ("practice the black art")
    
    def move(self):
        print ("fly")

    def eat(self):
        print ("no eat")  # <--- 요정은 밥을 안먹지 않을까요? 그래도 선언해줘야 함(상관없는 기능)

        
class Human(Character):
    def attack(self):
        print ("plunge a knife")
    
    def move(self):
        print ("run")

    def eat(self):
        print ("eat foods")

# 추상 클래스 선언하기
from abc import *

class Character(metaclass=ABCMeta):
    @abstractmethod
    def attack(self):
        pass
    
    @abstractmethod
    def move(self):
        pass

# 추상 클래스 상속하기
class Elf(Character):
    def attack(self):
        print ("practice the black art")
    
    def move(self):
        print ("fly")
        
class Human(Character):
    def attack(self):
        print ("plunge a knife")
    
    def move(self):
        print ("run")

    def eat(self):  # <--- 메서드 확장
        print ("eat foods")

elf1 = Elf()
human1 = Human()

elf1.attack()
elf1.move()
human1.attack()
human1.move()
human1.eat()

from abc import *

class AttackingWay(metaclass=ABCMeta):
    @abstractmethod
    def attack(self):
        pass

class MovingWay(metaclass=ABCMeta):
    @abstractmethod
    def move(self):
        pass

class EatingWay(metaclass=ABCMeta):
    @abstractmethod
    def eat(self):
        pass

class AbstractHumanCharacter(AttackingWay, MovingWay, EatingWay):
    pass

# 추상 클래스 상속하기
class Elf(AttackingWay, MovingWay):
    def attack(self):
        print ("practice the black art")
    
    def move(self):
        print ("fly")
        
class Human(AttackingWay, MovingWay, EatingWay):
    def attack(self):
        print ("plunge a knife")
    
    def move(self):
        print ("run")

    def eat(self):
        print ("eat foods")

elf1 = Elf()
human1 = Human()

elf1.attack()
elf1.move()
human1.attack()
human1.move()
human1.eat()

from abc import *

class UsingKnife(metaclass=ABCMeta):
    @abstractmethod
    def use_knife(self):
        pass

class UsingWizard(metaclass=ABCMeta):
    @abstractmethod
    def use_wizard(self):
        pass

class Warrior(UsingKnife):
    def use_knife(self):
        print ('칼로 찌른다')

class Elf(UsingWizard):
    def use_wizard(self):
        print ('마법을 쓰다')

class Wizard(UsingWizard):
    def use_wizard(self):
        print ('마법을 쓰다')

warrior1 = Warrior()
elf1 = Elf()
wizard1 = Wizard()

warrior1.use_knife()

# 실습 코드
class BubbleSort:
    def bubble_sort(self):
        # sorting algorithms
        pass

# 나쁜 예
class SortManager:
    def __init__(self):
        self.sort_method = BubbleSort() # <--- SortManager 는 BubbleSort에 의존적
        
    def begin_sort(self):
        self.sort_method.bubble_sort() # <--- BubbleSort의 bubble_sort 메서드에 의존적

# BubbleSort의 bubble_sort 메서드 변경
class BubbleSort:
    def sort(self):
        print('bubble sort')
        pass

sortmanager = SortManager()
sortmanager.begin_sort()

sorting1 = SortManager()
sorting1.begin_sort()

# 좋은 예
class SortManager:
    def __init__(self, sort_method):    # <--- 의존성을 주입시킨다고 이야기함
        self.set_sort_method(sort_method)
        
    def set_sort_method(self, sort_method):
        self.sort_method = sort_method
        
    def begin_sort(self):
        self.sort_method.sort()         # <--- 하부 클래스가 바뀌더라도, 동일한 코드 활용 가능토록 인터페이스화

# 실습 코드
class BubbleSort:
    def sort(self):
        print('bubble sort')
        pass

class QuickSort:
    def sort(self):
        print('quick sort')
        pass

bubble_sort1 = BubbleSort()
quick_sort1 = QuickSort()

sorting1 = SortManager(bubble_sort1)
sorting1.begin_sort()

sorting2 = SortManager(quick_sort1)
sorting2.begin_sort()

# 좋은 예
class SortManager:
    def __init__(self, sort_method):    # <--- 의존성을 주입시킨다고 이야기함
        self.set_sort_method(sort_method)
        
    def set_sort_method(self, sort_method):
        self.sort_method = sort_method
        
    def begin_sort(self):
        self.sort_method.sort()         # <--- 하부 클래스가 바뀌더라도, 동일한 코드 활용 가능토록 인터페이스화

class SelectionSort:
    def sort(self):
        print('selection sort')
        pass

selection_sort = SelectionSort()
sorting3 = SortManager(selection_sort)
sorting3.begin_sort()