TigerCow.Door


안녕하세요. 문범우입니다.

이번 포스팅에서는 SOLID 원칙에 대해서 알아봅니다. SOLID는 5가지 원칙을 줄여서 말하는 내용인데, 한번에 5가지 모두를 알아보지 않고, 각 원칙에 대해서 코드로 함께 살펴보며 총 5개의 포스팅으로 나누어 설명드릴 예정입니다.



0. SOLID란?


우선 솔리드, SOLID는 객체 지향 프로그래밍 및 설계의 다섯가지 기본 원칙을 이야기한다. 프로그램이 시간이 지나도 유지 보수 및 확장이 쉬울 수 있도록 하기 위한 원칙이며, 우리가 학습하고자 했던 클린코드를 위한 원칙이기도 하다. 


조금 더 구체적으로, SOLID는 아래와 같은 5가지 원칙을 이야기 한다.


1. Single Responsibility Principle(단일 책임 원칙)


2. Open/Closed Principle(개방/폐쇄 원칙)


3. Liskov Substitution Principle(리스코프 치환 원칙)


4. Interface Segregation Principle(인터페이스 분리 원칙)


5. Dependency Inversion Principle(의존관계 역전 원칙)


이제 우리는 각 원칙에서 강조하는 것과, 실제로 그것을 코드로서 간단하게 살펴보며 이해를 해보도록 하겠다.




1. SRP(Single Responsibility Principle)


단일 책임 원칙(SRP)이란 하나의 클래스는 하나의 책임만 가지며, 그 책임에 대해 완전히 캡슐화 해야 함을 말한다. 

클래스가 하나의 책임만 가진다는 것은, 하나의 클래스는 하나의 일을 담당하고 있으며, 클래스를 변경해야 할 이유는 오직 한가지가 존재한다는 것으로 생각할 수 있다. 이러한 원칙은, 코드의 응집력을 높이는데 도움을 준다. 


간혹 하나의 클래스가 다양한 책임을 지고 있는 경우가 있는데, 이러한 클래스(객체)를 일컬어 신(god) 객체라고 이야기 한다. 이러한 신 객체가 존재하면 시스템에 대한 유지보수가 어려워진다.


어떤 면에서 단일 책임 원칙은, 관계형 데이터베이스 설계에서의 정규화 개념과 유사하다고 생각할 수 있다. 만약 객체의 속성이나 메서드 중에서 서로 특성이 다른 요소(그룹)가 발견되면 그러한 것들을 적절히 분리시켜야 한다.


이제 실제로 코드를 통해 너무 많은 책임을 가진 클래스와, 이를 단일 책임 원칙에 따라 분리한 예제를 살펴보도록 하자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Course:
    """너무 많은 책임을 가진 Course 클래스"""
    
    def __init__(self, code, name, schedule, pf):
        self.code = code
        self.name = name
        self.schedule = schedule
        self.pf = pf
    
    def connect(self, con)->bool:
        """DB connecting"""
        pass
    
    def close(self)->bool:
        """DB close"""
        pass
    
    def get_course_by_pf(self, professor)->list:
        """professor로 강의 찾기 함수"""
        pass
    
    def save_course(self, Course)->bool:
        """DB에 course 저장하기"""
        pass
    
    def update_course(self, code)->bool:
        """특정 code를 가진 course를 DB update 하기"""
        pass
cs

code: https://github.com/doorBW/python_clean_code


먼저 위의 Course 클래스를 살펴보자.

해당 Course 클래스는 너무 많은 책임을 가지고 있다. 클래스의 생성자 __init__함수가 정의되어 있으면서 DB접근과 관련된 함수들도 함께 정의되어 있다.

즉, Course 객체의 속성들에 대한 관리를 하고 있으면서, Course의 DB 내용에 대한 관리도 하고 있다. 이러한 경우 DB에 대한 시스템 변경이 있을 때나, Course의 속성에 대한 변경이 있을 때 동일한 클래스를 수정하고 서로 영향이 없도록 신경써야 한다.

따라서 위와 같은 클래스는 아래와 같이 분리할 수 있다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
class Course:
    """SRP원칙을 준수한 Course 클래스"""
    
    def __init__(self, code, name, schedule, pf):
        self.code = code
        self.name = name
        self.schedule = schedule
        self.pf = pf
 
class CourseDB:
    """SRP원칙을 준수한 CourseDB 클래스"""
    def __init__(self, con):
        self.con = con
    
    def connect(self)->bool:
        """DB connecting"""
        pass
    
    def close(self)->bool:
        """DB closing"""
        pass
    
    def get_course_by_pf(self, professor)->list:
        """professor로 강의 찾기 함수"""
        pass
    
    def save_course(self, Course)->bool:
        """DB에 course 저장하기"""
        pass
    
    def update_course(self, code)->bool:
        """특정 code를 가진 course를 DB update 하기"""
        pass
cs

code: https://github.com/doorBW/python_clean_code


이전과 달리 Course 클래스와 CourseDB 클래스로 나누어, DB를 관리하는 클래스를 따로 분리하였다. 

이렇게 됨으로써 각 클래스가 자신이 담당한 하나의 일에 대해서만 책임을 지게 된다.


이번에는 다른 예제를 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Human:
    """추상화 과정이 필요한 Human 클래스"""
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
        
    def go_restroom(self):
        """화장실 가는 함수"""
        if(self.sex == '남자'):
            print("남자화장실로 간다.")
        elif(self.sex == '여자'):
            print("여자화장실로 간다.")
        else:
            print("성별을 지정해주세요.")
 
cs

code: https://github.com/doorBW/python_clean_code


위의 Human 클래스에서는 객체 생성시에 성별을 정의하게 되어있다. 그리고 go_restroom에서는 성별에 따라 분기처리하여 로직을 처리한다. 즉, Human클래스는 성별이 다른 두가지 케이스에 대한 책임을 동시에 가지고 있다. 이러한 경우 Human 클래스를 다음과 같이 추상화시킴으로써 해결할 수 있다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
from abc import *
 
class HumanBase(metaclass=ABCMeta):
    def __init__(self, name):
        self.name = name
    
    @abstractmethod
    def go_restroom(self):
        pass
    
class Male(HumanBase):
    def __init__(self, name):
        super().__init__(name)
        self.sex = "남자"
    
    def go_restroom(self):
        print("남자화장실로 간다.")
        
class Female(HumanBase):
    def __init__(self, name):
        super().__init__(name)
        self.sex = "여자"
        
    def go_restroom(self):
        print("여자화장실로 간다.")
cs

code: https://github.com/doorBW/python_clean_code


위와 같이 추상클래스, HumanBase 클래스를 만들어 주었다. 기본적으로 생성시에는 이름만 받고 이를 상속받은 클래스들은 go_restroom을 구현하게끔 하였다.

그리고 HumanBase를 상속받는 Male 클래스와 Female 클래스를 정의함으로써, 성별이 다른 경우에 대해 각 클래스가 유일한 책임을 가지도록 하였다.


이렇게 우리가 SOLID에서 단일 책임 원칙에 대해 알아보면서 대표적인 두가지 예제를 살펴보았다.

첫번째, Course 클래스에서는 단일 클래스에서 너무 많은 액션, 업무를 담당하고 있어 이를 분리함으로써 단일 클래스가 하나의 책임만 가지도록 하였다.

두번째, Human 클래스에서는 보다 높은 추상과 과정을 통해서 각 클래스가 하나의 책임만 가지도록 설정하였다.


이렇게 단일 책임 원칙을 지킨 경우에 클래스에 대한 외부 영향도를 최소화 할 수 있으며, 결국 유지보수나 확장 면에서 보다 효율적일 수 있다.


블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


안녕하세요. 문범우입니다.

이번 포스팅에서는 파이썬에서의 인자(Argument)에 대해서 알아보도록 하겠습니다.

파이썬에서 인자가 어떻게 작동하는지, 그리고 가변인자와 같은 개념들도 함께 알아보도록 하겠습니다.



0. 인자(Argument)와 매개변수(Parameter)


본격적으로 인자에 대해서 알아보기전에, 자주 헷갈릴 수 있는 인자와 매개변수에 대해서 잠깐 짚고 넘어가도록 하자. 물론 이는 파이썬언어 뿐만이 아니라 다른 언어에서도 혼동되서 사용될 수 있는 개념이다.


1
2
3
4
5
def func1(param1, param2):
    print(f"param1:{param1}, param2:{param2}")
 
func1("AA","B")
# param1:AA, param2:B
cs


위의 코드를 살펴보며 이야기해보자.

함수 func1에는 param1과 param2가 전달되도록 정의되어있다. 이렇게 함수가 정의되는 내용에 포함되는 특성을 매개변수(Parameter)라고 한다. 즉, 함수 func1는 2개의 매개변수, param1과 param2를 전달받아서 이를 출력하는 기능을 하는 것이다.

그리고 4번 라인에서는 func1에 "AA"라는 값과 "B"라는 값을 전달하며 함수를 호출하고 있다. 이때 함수에 전달하는 값을 인자(Argument)라고 한다.


이러한 차이에 의해서 매개변수(Parameter)는 변수(Variable)로 보아야 하며, 인자(Argument)는 값(Value)로 보아야한다. 두 개념이 비슷하다고 생각할 수 있으나, 함수에 대해서 이야기를 할때에는 구분해서 사용해야 혼동되지 않을 수 있다.




1. 파이썬에서 인자의 전달방식


앞에서 인자에 대해서 설명할 때, 함수를 호출하며 값으로 전달되는 것이라고 설명했다. 하지만 사실 함수에 '값(Value)'로 전달되는 것은 특정 상황에서만이다.

함수에 인자가 전달될 때에는, 실제로 그 값이 넘어가는 "값에 의한 호출(Call by Value)"와 값이 참조하고 있는 참조값이 넘어가는 "참조에 의한 호출(Call by Reference)" 두가지가 존재한다.

(만약 당신이 C언어를 했다면 포인터를 공부하면서 이 개념을 접했을 수도 있다.)


각각의 호출방법이 어떤 차이가 있는지 먼저 코드로 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def call_by_value(param1:int)->None:
    param1 += 1
    print(f"call by value: {param1}")
    
def call_by_ref(param2:list)->None:
    param2[0+= 1
    print(f"call by ref: {param2}")
    
val1 = 3
val2 = [3]
 
print(f"before val1:{val1}")
call_by_value(val1)
print(f"after val1:{val1}")
print("- - - - - - - - - - ")
print(f"before val2:{val2}")
call_by_ref(val2)
print(f"after val2:{val2}")
# before val1:3
# call by value: 4
# after val1:3
# - - - - - - - - - - 
# before val2:[3]
# call by ref: [4]
# after val2:[4]
cs


위의 코드에서는 call_by_value 함수와 call_by_ref함수를 정의하여 사용하고 있다. 각각의 함수가 받는 매개변수의 타입은 다르지만, 그 이유에 대해서는 뒤에서 이야기하겠다. 우선 "값에 의한 호출"과 "참조에 의한 호출"에 대한 차이를 이해해보자.


우리가 주목해야 할 것은 19번줄부터 25번줄까지의 결과이다. val1과 val2 모두 함수를 거치기 이전에 출력을 한 다음, 함수 호출시 함수 내부에서 출력한 후에, 함수 호출이 끝난 후에 출력을 한다.

먼저 val1의 값을 보면, 함수 호출 이전에 3이란 값을 출력하고, 함수 내부에서 출력될 때에는 1을 더한 4가 출력되고 있다. 그리고 함수가 끝난 다음에는 값이 변화하지 않고 그대로 3을 출력한다. 즉, 함수에서 더한 1이 val1에 영향을 미치지 않았다.

그럼 이번에는 val2의 값을 살펴보자. 당연히 함수 호출 이전에는 3을 출력했다. 그리고 함수 내부에서 출력될 때에는 1을 더한 4가 출력되었다. 여기까지는 val1과 같았지만, 함수 호출이 끝난 뒤 val2를 출력했을 때에는, val1과 달리 기존의 val2=3값에서 변화가 되어 4를 출력하였음을 볼 수 있다.


즉, val1은 함수에서 내부적으로 1을 더했지만, 기존의 값에 영향을 미치지 않았고, val2는 함수에서 더한 1이 실제 값이 영향을 미쳤다.

이것이 바로 "값에 의한 호출"과 "참조에 의한 호출"에 대한 차이로 발생한 것이다.


값에 의한 호출을 할 때에는, 함수로 인자가 전달될 때 동일한 "값"을 가진 객체를 복사하여 함수에 전달한다. 즉, 위의 코드에서 val1이 call_by_value함수에 전달될 때에는 사실 val1자체가 전달된 것이 아니고, val1이 가진 값을 동일하게 가진 또다른 객체가 함수로 전달된 것이다. 그리고 함수에서 1을 더한것은 val1이 아니고 val1과 똑같은 값을 가진 "val1과 다른 객체"에 더한 것이다. 이로 인해 함수에서 전달받은 값에 대해 변화를 시도해도 기존의 val1값은 변화가 없는 것이다.


이와 달리, 참조에 의한 호출을 할 때에는, 함수로 인자가 전달될 때 실제로 인자가 가진 "참조 값"을 전달한다. 참조 값을 전달한다는 것은 실제로 인자 객체를 그대로 전달한다고 생각해도 된다. 즉, 값에 의한 호출에서와 달리 인자를 복사한 객체를 전달하는 것이 아니라, 말 그대로 인자 그 자체를 전달하는 것이다. 따라서 함수내부에서 전달받은 인자에 대해 변화를 주면, 실제로 그 인자에 영향이 있게 된다.


이것이 "값에 의한 호출"과 "참조에 의한 호출"의 차이이다.


C언어의 경우에는 인자를 값에 의한 호출로 전달할 것인지, 참조에 의한 호출로 전달할 것인지를 명시적으로 정해줄 수 있다. 하지만 파이썬 같은 경우는 이를 명시적으로 나타내지 않는다.

그럼 파이썬에서는 "값에 의한 호출"과 "참조에 의한 호출"을 어떻게 구분할 수 있을까?

위의 코드를 통해 짐작했을 수도 있다. 파이썬에서는 따로 호출에 대한 명시적인 구분을 두지 않고, 함수에 전달되는 인자의 타입(type)에 의해서 결정된다.

변수 타입에는 불변형(immutable) 객체와, 가변형(mutable) 객체가 있다. 즉 값의 수정이 허용되지 않는 변수 타입이 있으며, 값의 수정이 허용되는 변수 타입이 있다.

이를 통해, 함수에 전달되는 인자가 불변형 객체, 값의 수정이 허용되지 않는 변수타입이라면 이는 "값에 의한 호출"로 함수에 전달된다. 하지만 함수에 전달되는 인자가 가변형 객체, 값의 수정이 허용되는 변수타입이라면 이는 "참조에 의한 호출"로 함수에 전달된다.

때문에 이를 파이썬 공식 문서에서는 call by value나 call by reference라는 설명이 아닌, call by assignment라고 설명하고 있다. 함수에 할당되는 변수의 타입에 따라서 그 방식이 달라지기 때문이다.

파이썬에서 불변형객체, 가변형객체는 아래와 같이 나뉜다.


* 불변형(immutable) 객체

int, float, str, tuples 등


* 가변형(mutable) 객체

list, set, dict 등




2. 가변 인자


파이썬에서는 다른 언어와 같이, 가변인자 함수를 지원한다. 가변인자 함수라 함은 인자의 개수가 정해지지 않은 함수라고 생각하면 된다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def args_test_func1(a, b, c):
    print("* call args_test_func1")
    print(f"a:{a}, b:{b}, c:{c}, a+b+c:{a+b+c}")
    print("* END args_test_func1", end='\n\n')
    
def args_test_func2(a, b, *args):
    print("* call args_test_func2")
    print(f"a:{a}, b:{b}, args:{args}, a+b+c:{a+b+sum(args)}")
    print("* END args_test_func2", end='\n\n')
    
args_test_func1(1,2,3)
args_test_func2(1,2,3)
args_test_func2(1,2,3,4,5,6)
# * call args_test_func1
# a:1, b:2, c:3, a+b+c:6
# * END args_test_func1
 
# * call args_test_func2
# a:1, b:2, args:(3,), a+b+c:6
# * END args_test_func2
 
# * call args_test_func2
# a:1, b:2, args:(3, 4, 5, 6), a+b+c:21
# * END args_test_func2
cs


위의 코드에서 2개의 함수를 정의했다. args_test_func1 함수는 우리가 기존에 보던 함수처럼 a,b,c 3개의 매개변수를 정의한 함수이다. 아래 결과에서도 3개의 인자를 전달해 함수가 올바르게 기능했다.

이와 달리 args_test_func2 함수에서는 a,b라는 매개변수와 함께, *args 라는 매개변수를 정의하였다. 이렇게 *를 이용한 매개변수는 가변인자를 받을 수 있는 것으로 해석된다. 즉, 개수가 정해지지 않은 인자를 args라는 이름으로 받아서 처리하겠다는 것이다.

실제로 13번 줄에서 3개 이상의 인자를 함수에 전달했는데, 3부터 6까지는 args라는 이름으로 받아서 처리한 것을 볼 수 있다. 약간의 차이점은 args로 받은 인자는 튜플로 받아서 처리했다는 점이다.


이렇게 *를 사용하는 것을 패킹(packing)한다고 말하기도 하는데, 다음의 코드를 보면 그 의미가 더 와닿을 것이다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def packing_func1(a, b, c):
    print(f"a:{a}, b:{b}, c:{c}, a+b+c:{a+b+c}")
    
packing_list = [1,2,3]
packing_func1(packing_list)
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# <ipython-input-15-aaa44dbee827> in <module>
#       3 
#       4 packing_list = [1,2,3]
# ----> 5 packing_func1(packing_list)
 
# TypeError: packing_func1() missing 2 required positional arguments: 'b' and 'c'
 
packing_func1(*packing_list)
# a:1, b:2, c:3, a+b+c:6
 
cs


packing_func1은 이전와 같이 3개의 매개변수를 정의한 함수이다. 그리고 이 함수를 호출하기 위해 3개의 int값을 가지는 리스트, packing_list를 정의했다. 그리고 해당 리스트를 그대로 인자로 전달하면 에러가 발생한다. 타입의 맞고 틀림을 떠나서, packing_func1에서는 3개의 인자가 필요한데, 1개의 인자만 전달했기 때문이다.

이를 해결하기 위해서는 파이썬의 *를 이용한 패킹 기법을 사용하면 된다. 즉, 15번 줄과 같이 packing_list를 *를 통해 패킹함으로써 3개의 인자에 대응하는 값을 전달할 수 있다.




3. 가변 키워드 인자


가변 키워드 인자는 위에서 알아본 가변 인자와 비슷하다. 가변인자에서는 별표( * )를 하나 사용했지만, 가변 키워드 인자에서는 별표( * )를 2개 사용한다.


1
2
3
4
5
def kwargs_test_func1(**kwagrs):
    print(f"kwagrs:{kwagrs}")
    
kwargs_test_func1(key="value", test="wow")
# kwagrs:{'key': 'value', 'test': 'wow'}
cs


가변 키워드 인자가 가변 인자 개념과 다른 점은, **kwagrs로 정의된 매개변수는 인자로 받은 값을 "딕셔너리"형태로 패킹한다는 것이다.

따라서 **가 붙은 매개변수는 딕셔너리형태로 함수 내에서 활용할 수 있다.

또한 가변 인자에서와 같이, 기존의 딕셔너리 자료형을 함수에 전달할 때, 다음과 같이 사용할 수 있다.


1
2
3
4
5
6
7
8
9
def kwargs_test_func2(a, b, c):
    print(f"a:{a}, b:{b}, c:{c}, a+b+c:{a+b+c}")
    
kwagrs_dict = {
    'a'1'b'2'c'3
}
 
kwargs_test_func2(**kwagrs_dict)
# a:1, b:2, c:3, a+b+c:6
cs



블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요



안녕하세요. 문범우입니다.

이번 포스팅에서는 상속과 컴포지션에 대해서 알아보도록 하겠습니다.

어떤 경우에 상속을 쓰는 것이 올바른 것인지, 그리고 파이썬에서 상속과 파이썬을 어떻게 사용하는지에 대해서 코드로 함께 살펴보겠습니다.



1. 상속(Inheritance)


상속이란 기본적으로 자신이 가진 속성과 메소드를 물려주는 클래스(부모클래스, Parent class, Super class)와 이를 물려받는 클래스(자식클래스, Child class, Sub class)로 이루어진다.

객체 지향적 소프트웨어를 디자인하고 구현할 때 상속은 중요한 개념으로, 또 자주 사용된다. 하지만 이를 다시 생각해보자. 상속개념을 활용하면 부모클래스와 자식클래스간에 강력한 결합력(Coupling)이 발생하게 된다.

좋은 코드, 유지보수를 위한 코드를 생각할 때 결합력을 낮추고, 응집도는 높여야 한다고 했는데, 이러한 점을 고려하면 상속이 무조건적으로 좋은 방안은 아닐 수 있다.

즉, 상속이란 것이 좋은 경우와 그렇지 않은 경우를 잘 선별해가며 활용할 수 있어야한다.


만약 새로운 자식클래스를 만들었을 때 해당 자식클래스가 올바르게 정의된 클래스인지 확인하기 위해서는 상속받은 모든 메서드를 실제로 자식클래스에서 사용하는지를 살펴보아야 한다. 만약 대부분의 메소드를 실제로 필요로 하지 않는다면 다음과 같은 이유로 설계상의 실수일 수 있다.


- 부모클래스가 잘 정의된 인터페이스 대신 막연한 정의와 너무 많은 책임을 가진 경우

- 자식클래스가 확장하려고 하는 부모클래스의 적절한 세분화가 아닌경우


따라서, 상속을 쓰는 올바른 경우는 새로 정의하고자 하는 자식클래스가 부모클래스의 기능을 그대로 물려받으면서 이중 특정 기능을 수정하고자 하거나, 추가적인 기능을 구현하고자 할 때이다.


또한 상속에서도, 인터페이스 정의는 또 다른 상속의 올바른 경우로 생각할 수 있다. 어떤 객체에 인터페이스 방식을 강제하고자 할 때, 실제 기능을 구현하지 않은 추상클래스를 만들고, 이를 상속받는 자식클래스에서 실제로 기능을 구현하게 한다. 


그럼 올바르지 않은 상속의 경우는 어떠한 케이스가 있을까? 바로 예시 코드를 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import collections
from datetime import datetime
 
class TransactionalPolicy(collections.UserDict):
    """잘못된 상속의 예시"""
    
    def change_in_policy(self, customer_id, **new_policy_data):
        self[customer_id].update(**new_policy_data)
 
 
policy = TransactionalPolicy({
    "client001":{
        "fee"1000.0,
        "expiration_date": datetime(2020,1,3),
    }
})
 
policy["client001"]
# {'fee': 1000.0, 'expiration_date': datetime.datetime(2020, 1, 3, 0, 0)}
 
policy.change_in_policy("client001",expiration_date=datetime(2020,1,4))
policy["client001"]
# {'fee': 1000.0, 'expiration_date': datetime.datetime(2020, 1, 4, 0, 0)}
 
cs


위의 코드를 살펴보면 TransactionalPolicy 클래스는 파이썬 내장 collections의 사전자료형을 상속받아 구현하였다. 그리고 TransactionalPolicy 클래스에서 사용하고자 하는 change_in_policy 함수를 구현하였다.


이후 policy 라는 TransactionalPolicy 객체를 만들어 추가한 함수를 사용하였다. 이처럼 원하는 기능을 수행하는 클래스를 구현하였지만, 과연 이 클래스가 사전자료형을 상속하는 것이 올바른 것일까? 파이썬에서 객체가 사용가능한 메서드를 출력해주는 dir함수를 이용하여 policy객체가 이용가능한 메서드를 살펴보자.


1
2
3
4
5
6
7
8
dir(policy)
# ['_MutableMapping__marker', '__abstractmethods__', '__class__', '__contains__', '__copy__', '__delattr__',
# '__delitem__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
# '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__',
# '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__',
# '__sizeof__', '__slots__', '__str__', '__subclasshook__', '__weakref__', '_abc_impl',
# 'change_in_policy', 'clear', 'copy', 'data', 'fromkeys', 'get', 'items',
# 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
cs


policy 객체를 보면 우리가 추가로 구현한 change_in_policy 라는 함수 이외에도 다양한 함수가 있다. 정말 해당 객체에서 pop, popitem 등의 함수가 필요로 한 것일까? 필요하지 않을텐데 포함되어 있다. 더군다나 해당 함수들은 public 메서드이기 때문에 이를 사용하게 될 가능성도 있다. 이러한 것을 살펴보아, TransactionalPolicy 클래스가 사전자료형을 상속받은 것은 올바르지 않다고 볼 수 있다.


더군다나, 의미적으로 보았을 때 부모클래스로부터 상속을 받은 자식클래스는 개념적으로 확장되거나, 세부적이라는 것을 의미해야 한다. 하지만 TransactionalPolicy 클래스가 사전자료형에 대해서 개념적으로 확장되거나 세부적이라는 것이라고 생각할 수 있을까?


그럼, 우리는 TransactionalPolicy 클래스를 정의하기 위해서 어떻게 해야할까?


이러한 경우 컴포지션이라는 개념을 활용해볼 수 있다.



2. 컴포지션(Composition)


컴포지션이란, 상속과 다르게 단순히 사용한다는 개념이다. 즉, 기존의 상속 개념에서의 자식클래스가 부모클래스의 모든 속성을 물려받는게 아니라, 자식클래스가 필요한 속성만 부모클래스로부터 가져와 사용하는 것이다.

일반적으로 상속은 암시적 선언이라고 하며, 컴포지션은 명시적 선언이라고 한다.


그럼 바로 컴포지션은 어떻게 사용되는지 위에서의 예시를 가져와 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class NewTransactionalPolicy:
    """컴포지션을 활용한 예시"""
    
    def __init__(self, policy_data, **extra_data):
        self._data = {**policy_data, **extra_data}
    
    def change_in_policy(self, customer_id, **new_policy_data):
        self._data[customer_id].update(**new_policy_data)
        
    def __getitem__(self, customer_id):
        return self._data[customer_id]
    
    def __len__(self):
        return len(self._data)
 
new_policy = NewTransactionalPolicy({
    "client001":{
        "fee"1000.0,
        "expiration_date": datetime(2020,1,3),
    }
})
 
new_policy["client001"]
# {'fee': 1000.0, 'expiration_date': datetime.datetime(2020, 1, 3, 0, 0)}
 
new_policy.change_in_policy("client001",expiration_date=datetime(2020,1,4))
new_policy["client001"]
# {'fee': 1000.0, 'expiration_date': datetime.datetime(2020, 1, 4, 0, 0)}
cs


이전의 예시와 달리 NewTransactionalPolicy 클래스에서는 사전자료형을 상속받지 않았다.

하지만 __init__함수에서 _data를 private로 선언하면서 사전자료형의 데이터로 초기화한다. 그리고 이후 우리가 사용하고자 하는 change_in_policy함수와 __getitem__함수에서 _data, 즉 사전 자료형을 활용하여 구현하고자 하는 기능을 구현하였다.


이렇게 직접 사전자료형을 상속받지 않고, 단순히 사전자료형을 가져와서 사용하였다.

이를 통해 추후 사전자료형에서 변경이 발생하더라도 그 인터페이스만 잘 유지된다면 NewTransactionalPolicy에서는 별도의 변경이 필요없다. 더군다나 이전에 dir함수를 통해 policy 객체가 사용가능한 메서드를 살펴본 것 처럼 new_policy 객체를 살펴보면 다음과 같다.


1
2
3
4
5
6
dir(new_policy)
# ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
#  '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__',
#  '__len__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
#  '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__',
#  '_data', 'change_in_policy']
cs


확실히 상속을 받았던 policy 객체에 비해, 사용 가능하지만 필요하지 않았던 함수가 사라진 것을 확인할 수 있다.



이렇게 상속과 컴포지션은 단순히 별개의 것이 아니라, 기존의 클래스를 재사용하는 상황에 있어서, 상속을 사용해야 할지 컴포지션을 사용해야 할 지 신중히 판단해야 한다. 단순히 현상황만을 고려한다기 보다는 상속과 컴포지션의 특성과, 장단점을 잘 생각하고 활용해야 새롭게 정의하는 클래스가 추후 가져올 문제를 최소화 할 수 있다.



블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


안녕하세요. 문범우입니다.

이번 포스팅에서는 개발 분야에서 사용되는 약어(Abbreviations)에 대해서 알아보려 합니다.

물론, 파이썬이라는 언어에서만 해당되거나 염두에 두어야 할 내용이라기 보다는, 프로그래밍에 있어서 어떠한 언어를 사용하던 각 약어들을 염두해두고 프로그래밍을 한다면 보다 좋은 코드를 작성할 수 있고, 특정 상황과 코드에 보다 적합한 아이디어를 얻을 수 있을 것 입니다.


1. DRY / OAOO


DRY(Do not Repeat Yourself)와 OAOO(Once And Only Once)는 강조하고자 하는 의미가 비슷하므로 함께 다루어보자. 두개의 약어는, '중복을 피하라'라는 의미를 가지고 있다.

즉, 특정 기능과 역할을 하는 것은 코드에 단 한 곳에 정의되어 있어야 하고 중복되지 않아야 한다. 그리고 이를 통해 코드를 변경하고자 할 때 수정이 필요한 곳은 단 한 군데 존재해야 한다.


코드의 중복이 발생한다는 건 유지보수를 하는데에 있어서 직접적인 영향을 미칠 수 있다는 것이다. 다양한 문제가 있을 수 있지만 축약해보면 다음과 같은 3가지 문제가 대표적이다.


- 오류가 발생하기 쉽다.

특정 계산 로직이 코드 전체 여러곳에 동일하게 분포되어 있을 때, 계산 로직에 대한 변경사항이 발생하면 코드의 모든 곳을 찾아 변경해주어야 하는데 이때 하나라도 빠뜨리면 오류가 발생하기 쉬워진다.


- 비용이 발생한다.

동일한 기능에 대한 반복 수정이 이루어져야 하기 때문에, 당연히 1회의 수정보다 다수의 수정에 있어서 비용적으로 손해가 발생한다.


- 신뢰성이 떨어진다.

동일한 기능이 코드 여러 곳에 분포되어 있을 때, 모든 곳을 찾아서 수정해야 한다. 물론 언어적 기능과 도구의 도움을 받을 수도 있지만, 모든 곳을 정확히 기억하지 못할 수 있다는 점 때문에 시스템 전체의 신뢰성이 보다 떨어질 수 있다.


간단하게 나마 코드의 중복이 발생할 수 있는 예시와 적절히 조치 된 예시를 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#-*- coding:utf-8 -*-
# DRY / OAOO
 
user_math_score_dic = {
    'A'90,
    'B'93,
    'C'30,
    'D'100,
    'E'31,
    'F'82,
    'G'79,
}
 
user_eng_score_dic = {
    'A'30,
    'B'63,
    'C'39,
    'D'94,
    'E'10,
    'F'49,
    'G'68,
}
 
# Danger code
def get_user_score_list(user_math_score_dic, user_eng_score_dic):
    """
    input: 유저의 이름을 key로, 점수를 value로 가지는 dict형 자료형 2개
    output: 종합 점수 계산에 따라 내림차순으로 정렬한 유저의 이름 list
    """
    
    user_sum_score_dic = {}
    # 종합 점수 계산 (math*2 + eng)
    for k, math_score in user_math_score_dic.items():
        sum_score = math_score*2
        sum_score += user_eng_score_dic[k]
        user_sum_score_dic[k] = sum_score
 
    # 종합 점수에 따라 내림차순 정렬
    sorted_user = sorted(user_sum_score_dic.keys(), key=lambda x: user_sum_score_dic[x])
    return sorted_user
 
print("# Danger code")
print(get_user_score_list(user_math_score_dic, user_eng_score_dic))
 
 
# Good code
def calc_user_sum_score(user_math_score_dic, user_eng_score_dic):
    """
    input: 유저의 이름을 key로, 점수를 value로 가지는 dict형 자료형 2개
    output: 종합 점수 계산이 된 dict 자료형
    """
    user_sum_score_dic = {}
    # 종합 점수 계산 (math*2 + eng)
    for k, math_score in user_math_score_dic.items():
        sum_score = math_score*2
        sum_score += user_eng_score_dic[k]
        user_sum_score_dic[k] = sum_score
    return user_sum_score_dic
 
def get_user_score_list2(user_math_score_dic, user_eng_score_dic):
    """
    input: 유저의 이름을 key로, 점수를 value로 가지는 dict형 자료형 2개
    output: 종합 점수 계산에 따라 내림차순으로 정렬한 유저의 이름 list
    """
    user_sum_score_dic = calc_user_sum_score(user_math_score_dic, user_eng_score_dic)
 
    # 종합 점수에 따라 내림차순 정렬
    sorted_user = sorted(user_sum_score_dic.keys(), key=lambda x: user_sum_score_dic[x])
    return sorted_user
 
print("# Good code")
print(get_user_score_list(user_math_score_dic, user_eng_score_dic))
 
cs


위의 코드를 보면 기존에 정의된 get_user_score_list함수에서는 내부적으로 종합 점수에 대한 계산이 진행되고 있다. 만약 그러한 계산 로직이 다른 곳에서도 필요하면 어떻게 될까? 따로 함수화가 되어 있지 않기 때문에 동일 로직을 중복시켜야 한다. 하지만 아래와 같이 calc_user_sum_score라는 함수를 분리해두면, 추후 동일 로직이 필요할 때 해당 함수를 이용할 수 있을 것이다.



2. YAGNI / KIS


YAGNI( You Aren't Gonna Need It)와 KIS(Keep It Simple) 또한 의미하는 바가 비슷하므로 함께 다루도록 하자. 두 약어가 의미하는 것은 '현재 주어진 문제에 적합한, 간단한 코드를 작성하라'이다.


YAGNI에서 보다 강조하는 것은, 과잉된 프로그래밍을 하지 말라는 것이다. 우리는 결론적으로 시스템에 대한 확장성과 유지보수 등을 위해 보다 좋은 코드를 작성하려고 한다. 하지만 그 목표가 코드를 작성하는 시점에 특정 미래적 상황을 예측해야 한다는 것은 아니다. 필자가 참고하고 있는 서적에서는 이렇게 이야기 한다.


유지보수가 가능한 소프트웨어를 만드는 것은 미래의 요구 사항을 예측하는 것이 아니다.

- 파이썬 클린 코드


위에서의 말대로, 우리가 확장성과 유지보수 등을 위한 소프트웨어를 만들어야 한다는 것은, 다가오지 않은 미래에 대해 특정 상황을 예측해야 한다는 것은 아니다. 오히려 그랬다면 코드적인 학습보다, 미래학자와 같은 학습을 해야하지 않을까 싶다. 

따라서, 프로그래밍 시점에서는 현재의 요구사항을 잘 해결하기 위한 소프트웨어를 작성하되, 이때에 보다 수정가능하고, 높은 응집도와 낮은 결합력을 가지는 프로그래밍을 해야한다. 미래에 ~이 필요할거야, 나중에 ~가 고려되지 않을까, 라는 생각에 현재의 요구사항을 넘어서는, 과잉 프로그래밍을 하면 안된다.


KIS에서 조금 더 강조하는 점은 현재에 선택한 솔루션이 최선의, 최소한의 솔루션이어야 한다는 것이다. 문제를 해결하는데에 있어서 화려하고 어려운 기술은 필수요소가 아니다. 항상 보다 간결하고 최소한의 솔루션으로 문제를 해결해야 한다.

단순하게 해결될 수 있는 문제를 보다 복잡하게 해결하게 되면 추후 해당하는 함수, 클래스, 데이터에 대한 수정에 있어 더 큰 어려움이 내포될 수 있다.


더군다나, 파이썬의 철학에서는 '단순한 것이 복잡한 것보다 낫다.' 라고 이야기 하고 있다.



3. EAFP / LBYL


EAFP(Easier to Ask Forgiveness than Permission)와 LBYL(Look Before You Leap)는 상대적인 의미를 지니고 있는 약어이다.


우선 EAFP는 허락보다 용서를 구하는 것이 쉽다는 말인데 이 의미는 일단 코드가 실행되도록 두고 동작하지 않을 경우를 대응한다는 의미이다. 일반적으로는 코드가 실행되도로 하고 발생할 수 있는 에러에 대해서 catch, except문을 이용해 조치하는 코드를 의미한다.


이에 반해 LBYL은 도약하기 전에 살피라는 말이며, 의미적으로는 코드가 실행되기 이전에 확인/검토를 하라는 의미이다. 간단하게는 if문 등을 이용한 체크 정도로 생각하면 된다.


아래 코드는 파일을 사용하기 이전에 LBYL에 따른 코드와, EAFP에 따른 코드를 나타내고 있다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# LBYL
if os.path.exists(filename):
    with open(filename) as f:
        ...
        
 
# EAFP
try:
    with open(filename) as f:
        ...
        
except FileNotFoundError as e:
    logger.error(e)
    ...
 
cs




블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


안녕하세요. 문범우입니다.

이번 포스팅에서는, 파이썬에서 제공되는 annotation에 대해서 알아보도록 하겠습니다.



1. Annotation 이란?


우선 Annotation의 사전적 정의는 "주석"이다. 즉, 쉽게 말해서 코드에 대한 추가적인 설명을 이야기하는 무언가를 의미한다.

대표적으로 Java언어에서 함수나 클래스 상단에 @를 통해 annotation을 표시한다.



위는 java의 spring 프레임워크를 사용한 코드 중 일부인데, 10번, 13번, 16번 라인을 보면 @를 통해 annotation을 사용하고 있음을 볼 수 있다. 물론 자바에서의 annotation과 파이썬에서의 annotation은 차이가 있을 수 있다. 하지만 기본적으로 로직이 되는 코드를 "도와주는" 의미에서는 크게 다르지 않다고 볼 수 있다.

(사실 java의 annotation과 같은 것을 파이썬에서는 decorator로 나타내기 때문에 엄밀히 말했을 때, 자바의 annotation과 파이썬의 annotation은 다르다고 볼 수 있다.)


보다 자세히, 파이썬에서의 annotation에 대해서 알아보자.

사실 파이썬에서는 annotation에 대한 강제성이 전혀 없다. 우리가 파이썬에서 #을 이용하거나, 지난 포스팅에서 알아본 docstring과 같이 안써도 되지만, 보다 좋은 코드가 될 수 있도록 추가적으로 관리해주는 것 중 하나일 뿐이다.

파이썬에서 사용하는 annotation의 기본 아이디어는, 코드를 사용하는 이에게 함수나 클래스에 대해 그 인자값의 형태 또는 반환값을 알려주자는 것이다.


함수에 대해서는 함수의 인자에 대한 타입에 대한 힌트를 적거나, 함수의 return값에 대한 타입을 알려줄 수 있다. 또한 파이썬 3.6이후로는 변수에 대해서도 직접 annotation을 달 수 있다. 즉, 클래스에서 사용되는 변수값에 대해 그 타입을 적어둘 수 있다는 것이다.



2. Annotation 사용하기


백문이 불여일견, 우선 Annotation을 사용한 파이썬 코드를 살펴보자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#-*- coding:utf-8 -*-
class AnnotationClassExample:
    """
    Annotation에 대한 예시를 확인하기 위한 class입니다.
    __annotation__ 속성을 통해
    class할당되는 first_param과 second_param에 대한 타입을 확인할 수 있습니다.
    """
    first_param: str
    second_param: int
 
    def set_first_param(self, value: str-> None:
        """
        AnnotationClassExample 클래스의
        first_param 값을 바인딩합니다.
        함수의 반환은 없습니다.
        """
        self.first_param = value
 
    def set_second_param(self, value: int-> bool:
        """
        AnnotationClassExample 클래스의
        second_param 값을 바인딩합니다.
        함수의 반환은 True or False 입니다.
        """
        if type(value) == int:
            self.second_param = value
            return True
        else:
            self.second_param = 0
            return False
 
def main():
    print("Annotation 만들어보기")
    new_class = AnnotationClassExample()
    print("\n* AnnotationClassExample 클래스의 annotations")
    print(new_class.__annotations__)
    print("\n* set_first_param 함수의 annotations")
    print(new_class.set_first_param.__annotations__)
    print("\n* set_second_param 함수의 annotations")
    print(new_class.set_second_param.__annotations__)
 
if __name__ == '__main__':
    main()
cs


https://github.com/doorBW/python_clean_code


위의 코드에서는 AnnotationClassExample 클래스와 그 내부에 2개의 변수를 가지고 있으며, 클래스 내부에 2가지 함수를 추가로 구현해두었다. 


우선 함수에 대한 annotation을 살펴보자.

11번, 19번 라인의 함수선언부를 살펴보면 함수의 인자에 대한 annotation과 함수의 return에 대한 annotation이 적용되었다. 이를 통해 함수를 사용하고자 하는 이는 함수의 인자가 어떤 타입을 가져야하는지, 그리고 함수를 통해 얻게되는 값의 타입은 무엇인지 보다 쉽게 알 수 있다.

또한 파이썬 3.6부터 변수에 대한 annotation이 가능하다고 했는데, 이는 8번, 9번 라인과 같이 클래스 내부의 변수에 대한 annotation으로 사용할 수 있다. 


이렇게 annotation을 적용하면, 그 개체에 대해 __annotations__ 이라는 속성이 생긴다. 그리고 해당 속성을 통해 우리가 적용해둔 annotation 값을 볼 수 있는 것이다.

실제로 위의 코드를 실행시켜 보면 main함수내에서 각 클래스와 함수에 대해 __annotations__ 속성을 호출하고, 그 결과는 다음과 같다.



우리가 코드에서 적용시켜준 annotation들이 출력되는 것을 확인할 수 있다.


위와 같이 annotation을 통해 함수나 변수 등에 미리 타입에 대한 힌트를 적어둘 수 있다.

물론 이 또한 파이썬에서 강제성이 있거나, 지켜야 한다는 것은 아니다. annotation은 말 그대로 '힌트'를 주는 것에 불과하다.





블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


안녕하세요. 문범우입니다.


파이썬 언어를 활용하는데 보다 좋은 코드, 유지보수가 가능한 코드, 팀원들과 함께 협업할 수 있는 코드를 작성하기 위해 다양한 방법을 알아보고자 합니다. 흔히들 이야기 하듯, 클린코드를 작성하는 방법에 대해서 파이썬에서는 어떻게 구현될까를 함께 알아볼 것 입니다.

물론 클린코드라는 것에 정확한 방법과 기준은 없습니다. 하지만 함께 알아보는 내용들을 통해 그를 위한 다양한 방법과 방향에 대해서는 알아볼 수 있을 것 입니다. 

하나씩 공부해보며 자신의 상황과 프로젝트에 맞게 적용시키면 좋을 것 같네요.


이번 포스팅에서는 그 첫번째로, 파이썬의 docstring에 대해서 알아보도록 하겠습니다.



0. 문서화


Docstring에 대해서 알아보기전에 문서화에 대해서 한번 짚어보자.

프로젝트를 진행해보거나, 다른 개발자와 함께 협업을 진행해본 개발자라면 '문서화'가 왜 필요한지 어느정도 느꼈을 수 있다.


여러분들은 지금 개발하고 있는 프로젝트, 지금 작성한 코드를 한달, 일년뒤에 보았을 때 코드를 작성할 때와 같이 부드럽게 코드리딩이 가능한가? 사실 한달, 일년도 아니다. 복잡한 로직과 다양한 처리를 진행하는 개발을 진행할 때면 당장 내일에 그 코드를 정확히 기억하기 힘든 경우도 많을 것이다.



물론 그렇게 리딩이 어렵다는 것은 로직 자체가 깔끔하지 못하다는 문제이지 않을까란 생각을 할 수도 있을 수 있다. 당연히 그 또한 중요하겠지만, 만약 내가 작성한 코드를 다른 동료 개발자가 본다면 어떠할까? 로직이 깔끔하지만 수많은 함수와 클래스들의 코드를 직접 리딩해가며 모든 로직을 '코드'만으로 이해하고 받아들인다는건 상상하는 것보다 매우 힘든 일이 될 수 있다.


하지만 만약 각각의 함수와 클래스, 기타 등등이 어떤 기능을 하는 것인지 알아볼 수 있도록 '문서화'를 해두었다면 어떨까? 내가 작성한 코드를 매우 오랜만에 보더라도 해당 함수의 매개변수는 어떤 타입인지, 해당 함수가 어떤 기능을 하는 것인지, 그리고 반환 값은 무엇인지 한번에 알아 볼 수 있어 해당 함수를 이용하거나 받아들이는데 매우 편리할 것이다. 

즉, 문서화를 통해서 구현된 코드에 대해 보다 명확하고 편리하게 설명할 수 있으며 특정 함수나 클래스 등을 다른 곳에서 사용하고자 할 때 그것들에 대해 손쉽고 명확하게 이해하고 사용할 수 있어 추가적인 개발에 있어 사전에 버그를 방지할 수 있을 것이다.


물론 위에서 이야기한 내용보다 '문서화'가 필요하고 중요한 이유는 더 다양하고 더 중요한 이유들이 있을 수 있지만 이정도라면 개발자 누구나 '문서화'가 왜 필요한지 어느정도 스스로 생각해 볼 수 있는 계기가 될 것이라 생각한다.



1. Docstring 이란?


그럼 왜 필자는 Docstring에 대한 이야기에 앞서 문서화를 이야기했을까?

Docstring은 쉽게 생각했을 때, 코드에 포함된 문서(Document)이다. 즉, 코드에 대한 문서화를 코드 밖에, 워드나 한글 파일, 엑셀을 이용해 따로 하는 것이 아니라 코드 내부에 문서화를 실시한다는 것이다.

특히나 파이썬과 같은 동적 타입의 언어이기 때문에 코드내부에 문서를 포함시키는 docstring 이 매우 좋다. 파이썬에서는 파라미터의 타입을 체크하거나 강제하지 않는다. 헌데 특정 함수나 클래스를 이용하거나 수정하고자 할때 그에 대한 설명이 명확하게 나와있다면 그러한 이용이나 수정이 매우 간편하게 진행될 것이다.


파이썬에서 docstring은 함수나 클래스 모듈등에 정의할 수 있다. 그리고 작성한 내용을 확인하기 위해서는 해당 객체의 __doc__ 라는 속성을 이용하면 된다. (더블언더바)


docstring에 대한 사용법을 알아보기 이전에 실제로 docstring이 정의된 예시를 확인해보자.



위의 사진은 파이썬에서 개체의 길이를 구하는데 사용하는 len함수의 docstring을 출력한 사진이다. 또 다른 예시는 dictionary개체의 docstring을 살펴보자.


 


위와 같이 dictionary 개체의 docstring을 보니, 어떻게 사용하는지도 설명을 첨부하였다.

만약 우리가 dictionary가 무엇인지 궁금했다면 이와 같이 docstring을 통해서 간략하게나마 확인할 수 있을 것이다.



2. Docstring 사용하기


그럼 직접 우리가 클래스나 함수에 대해서 Docstring을 만들어서 사용해보도록 하자.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class DocstringClassExample():
    """
    DocstringClassExample() 예제 클래스
    class에 대한 설명을 함께 적어준다.
    """
 
    def docstring_func_example():
        """
        Return 0 always
        """
        print("ocstring_func_example 함수를 실행하였습니다.")
        return 0
 
def main():
    print("Docstring 만들어보기")
    new_doc = DocstringClassExample()
    print("Class docstring start")
    print(new_doc.__doc__)
    print("Class docstring end")
    print()
    print("Function docstring start")
    print(new_doc.docstring_func_example.__doc__)
    print("Function docstring end")
 
 
if __name__ == '__main__':
    main()
cs


https://github.com/doorBW/python_clean_code


위와 같이 간단한 Class 하나와 함수하나를 만들었다.

docstring은 위와 같이 클래스나 함수 선언 바로 하단부에 따옴표 세개를 이용하면 된다.(쌍따옴표, 홀따옴표 무관하다.)

이렇게 만든 코드를 실행시켜보면 다음과 같이 결과가 출력된다.



docstring 자체를 만들어내는 것, 이를 사용하는 것은 함께 알아본 것 처럼 전혀 어렵지 않고 너무 간단하다.

하지만 보다 중요한 것은 이러한 기능을 놓치지 않고 이용하면서 보다 유지보수 좋은 코드를 지속적으로 만들어 나가는 것, 그리고 기존에 있던 docstring을 최신으로 유지하는 노력일 것이다.




블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요




안녕하세요. 문범우입니다.

이번에는 Data Base에서 데이터 모델링(Data Modeling)에 대해서 알아보도록 하겠습니다.

데이터 모델링을 보다 잘 이해하려면 앞에서 학습한 엔터티, 속성, 관계, 식별자에 대한 이해가 필요하므로 각 개념에 대해 이해가 가지 않는 부분이 있다면 아래 링크를 통해서 다시 한번 확인하면 좋습니다.




1. 모델링


1-1. 모델링이란?


모델링이라는 것은 우리 주변에 있는 사람, 사물, 개념 등 다양한 현상을 발생시키는 것들을 일정한 표기법에 의해 나타내는 것을 이야기 한다.

모델링에 대한 사전적 정의로는 아래와 같이 다양하게 존재한다.


- 가설적 또는 일정 양식에 맞춘 표현

- 어떤 것에 대한 예비표현으로 그로부터 최종대상이 구축되도록 하는 계획으로서 기여하는 것

- 복잡한 '현실세계'를 단순화시켜 표현하는 것



1-2. 모델링의 특징


모델링의 특징으로는 다음과 같이 대표적으로 3가지, 추상화, 단순화, 명확화 3가지로 요약할 수 있다.


1-2-1. 추상화(모형화, 가설적)

추상화는 현실세계를 일정한 형식에 맞추어 표현을 한다는 의미이다. 다양한 현상을 일정한 양식인 표기법에 의해 표현한다는 것이다.


1-2-2. 단순화

단순화는 복잡한 현실세계를 약속된 규약에 의해 제한된 표기법이나 언어로 표현하여 현실세계를 보다 쉽게 이해할 수 있도록 하는 개념을 의미한다.


1-2-3. 명확화

명확화란 누구나 이해하기 쉽도록 대상에 대한 애매모호함을 제거하고 보다 정확하게 현상을 기술하는 것을 의미한다.



1-3. 모델링의 3가지 관점


시스템의 대상이 되는 업무를 분석하여 정보시스템으로 구성하는 과정에서 업무의 내용과 정보시스템의 모습을 적절한 표기법으로 표현하는 것을 모델링이라고 한다면, 이러한 모델링은 크게 3가지 관점, 데이터관점, 프로세스관점, 데이터와 프로세스의 상관관점으로 구분할 수 있다.


1-3-1. 데이터 관점(What)

업무가 어떤 데이터와 관련이 있는지 또는 데이터간의 관계는 무엇인지에 대해서 모델링하는 방법


1-3-2. 프로세스 관점(How)

업무가 실제하고 있는 일은 무엇인지 또는 무엇을 해야 하는지를 모델링하는 방법


1-3-3. 데이터와 프로세스의 상관관점

업무가 처리하는 일의 방법에 따라 데이터는 어떻게 영향을 받고 있는지 모델링하는 방법



2. 데이터 모델링


2-1. 데이터 모델링이란


우선, 데이터 모델링의 기반이 되는 데이터 모델은 데이터베이스의 골격을 이해하고 그 이해를 바탕으로 SQL문장을 기능과 성능적인 측면에서 효율적으로 작성하기 위해 꼭 알아야 하는 핵심요소이다. 이러한 데이터 모델을 만드는 데이터 모델링은 다음과 같이 정의 될 수 있다.


- 정보시스템을 구축하기 윟나 데이터관점의 업무 분석 기법

- 현실세계의 데이터(What)에 대해 약속된 표기법으로 표현하는 과정

- 데이터베이스를 구축하기 위한 분석/설계 과정



2-2. 데이터 모델이 제공하는 기능


업무를 분석하는 관점에 있어서 데이터 모델은 다음과 같은 기능을 제공한다.


- 시스템을 현재 또는 원하는 모습으로 가시화하도록 도와준다.

- 시스템의 구조와 행동을 명세화 할 수 있게 한다.

- 시스템을 구축하는 구조화된 틀을 제공한다.

- 시스템을 구축하는 과정에서 결정한 것을 문서화한다.

- 다양한 영역에 집중하기 위해 다른 영역의 세부 사항은 숨기는 다양한 관점을 제공한다.

- 특정 목표에 따라 구체화된 상세 수준의 표현방법을 제공한다.



2-3. 데이터 모델링의 중요성과 유의점


데이터 모델링이 중요한 이유는 파급효과(Leverage), 복잡한 정보 요구사항의 간결한 표현(Conciseness), 데이터 품질(Data Quality)로 정리할 수 있다.


- 파급효과(Leverage)

데이터 모델링이 초기에 제대로 이루어지지 않는다면, 시스템이 구현되고 테스트 하는 과정 중 그 문제점이 나타날 수 있다. 일반적으로 단위테스트, 통합테스트 등 다양한 단계의 테스트를 진행하는데 데이터 모델링의 문제가 발생해 데이터 모델을 변경해야 하는 상황이 온다면 데이터 모델, 구조 변경에 따른 표준 영향 분석, 응용 변경 영향 분석 등 다양한 분석이 필요해진다. 또한 그 이후의 실질적 구조 변경 작업이 진행되어야 한다.


- 복잡한 정보 요구사항의 간결한 표현(Conciseness)

데이터 모델은 구축할 시스템의 정보 요구사항과 한계를 가장 명확하고 간결하게 표현할 수 있는 도구이다. 정보 요구사항이 정확하고 간결하게 표현되어야 해당 데이터 모델과 관련된 시스템을 구축하는 많은 사람들이 설계자의 생각대로 정보 요구사항을 이해할 수 있을 것이고, 이를 운용할 수 있는 서비스/어플리케이션을 개발하며 데이터 정합성을 유지할 수 있다.


- 데이터 품질(Data Quality)

데이터베이스에 담겨 있는 데이터는 기업/단체의 중요한 자산이다. 특정 데이터에 대해서는 그 기간이 늘어날 수록 활용가치가 더 높아지기도 한다. 헌데, 그러한 데이터의 정확성이 떨어지는 등 데이터 품질이 낮아진다면 어떨까? 이는 해당 데이터로 얻을 수 있었던 비즈니스 기회를 상실할 수도 있는 문제가 된다.

데이터 품질에 대한 고찰은 데이터가 쌓이는 초기에는 쉽게 인지를 못하는 경우가 대부분이기에 초기 부터 오랜 기간 숙성된 데이터를 전략적으로 활용하기 위해 데이터 품질에 대한 중요성을 기억해야 한다.



또한 위와 같은 중요성을 지키기에 앞서, 데이터 모델링을 할때 유의해야 할 점은 다음과 같다.


- 중복(Duplication)

데이터 모델은 같은 데이터를 사용하는 사람, 시간, 그리고 장소를 파악하는데 도움을 준다. 이러한 자식 응용은 데이터베이스가 여러 장소에 같은 정보를 저장하는 잘못을 하지 않도록 한다.


- 비유연성(Inflexibility)

데이터 모델을 어떻게 설계했느냐에 따라 사소한 업무변화에도 데이터 모델이 수시로 변경됨으로써 유지보수의 어려움을 가중시킬 수 있다. 데이터의 정의를 데이터의 사용 프로세스와 분리함으로써 데이터 모델링은 데이터 혹은 프로세스의 작은 변화가 애플리케이션과 데이터베이스에 중대한 변화를 일으킬 수 있는 가능성을 줄인다.


- 비일관성(Inconsistency)

데이터의 중복이 없더라도 비일관성은 발생할 수 있다. 예를 들어 신용 상태에 대한 갱신 없이 고객의 납부 이력 정보를 갱신하는 것이다. 개발자가 다른 데이터와 모순된다는 고려 없이 일련의 데이터를 수정할 수 있기 때문이다. 데이터 모델링을 할 때 데이터와 데이터간 상호 연관 관계에 대한 명확한 정의는 이러한 위험을 사전에 예방할 수 있도록 해준다.



2-4. 데이터 모델링의 3단계


데이터 모델링을 하는데에 있어서는 시간에 따라 진행되는 3가지 과정이 있다. 이는 추상화 수준에 따라 달라지며 개념적 데이터 모델링, 논리적 데이터 모델링, 물리적 데이터 모델링으로 정리 된다.





2-4-1. 개념적 데이터 모델링

추상화 수준이 높으며 업무 중심적이고 포괄적인 수준의 모델링을 진행한다. 전사적 데이터 모델링으로도 사용되며 EA 수립시에도 많이 이용한다.

어떠한 자료가 중요하고, 어떠한 자료가 유지되어야 하는지를 결정하는 내용도 포함된다. 이 단계에 있어서 주요한 활동은 핵심 엔터티와 그들 간의 관계를 발견하고, 그것을 표현하기 위해 엔터티-관계 다이어그램을 생성하는 것이다. 


개념적 데이터 모델링을 통해 조직의 데이터 요구를 공식화 하는 것은 두 가지의 중요한 기능을 지원한다.

1. 개념적 데이터 모델은 사용자와 시스템 개발자가 데이터 요구 사항을 발견할 수 있도록 지원한다.

2. 개념 데이터 모델은 현 시스템이 어떻게 변형되어야 하는가를 이해하는데 유용하다.



2-4-2. 논리적 데이터 모델링

시스템으로 구축하고자 하는 업무에 대해 Key, 속성, 관계 등을 정확하게 표현하는 단계의 모델링이다. 재사용성이 높은 특징을 갖는다.

이러한 논리적 데이터 모델링은 데이터베이스 설계 프로세스의 Input으로써 비즈니스 정보의 논리적인 구조와 규칙을 명확하게 표현하는 과정이다. 데이터 모델링 과정에서 가장 핵심이 되는 부분이기도 하다.

논리적 데이터 모델링에서 진행되는 중요한 과정 중에 하나는 정규화이다. 정규화는 논리적 데이터 모델 상세화 과정의 대표적인 활동으로, 논리적 데이터 모델의 일관성을 확보하고 중복을 제거하여 속성들이 가장 적절한 엔터티에 배치되도록 함으로써 보다 신뢰성있는 데이터 구조를 얻는데 목적이 있다.

논리적 데이터 모델의 상세화는 식별자 확정, 정규화, M:M 관계 해소, 참조 무결성 규칙 정의 등을 들 수 있으며, 추가적으로 이력 관리에 대한 전략을 정의한다.



2-4-3. 물리적 데이터 모델링

실제로 데이터베이스에 이식할 수 있도록 성능, 저장 등 물리적인 성격을 고려하여 설계하는 단계의 모델링이다.

데이터가 물리적으로 컴퓨터에 어떻게 저장될 것인가에 대한 정의를 진행하는 단계이며 이 단계에서 테이블, 칼럼 등으로 표현되는 물리적인 저장구조와 사용될 저장 장치, 자료를 추출하기 위해 사용될 접근 방법 등을 결정한다.



2-5. 데이터 독립성


일체적 구성에서 기능화된 구성의 가장 큰 목적은 상호간 영향에서 벗어나 개별 형식이 가지는 고유의 기능을 유지시키며 그 기능을 극대화하는 것이다. 이를 위해 데이터 모델링 과정에서는 데이터 독립성을 중요시 한다.



2-5-1. 데이터 독립성의 필요성


데이터 독립성은, 끊임없이 요구되는 사용자 요구사항에 대해 화면과 데이터베이스 간에 서로 독립성을 유지하기 위한 목적으로 개념이 출현했다고 할 수 있다. 즉, 구조화 된 시스템이 시간이 지날수록 유지보수 비용이 증가하고, 데이터복잡도가 증가하며, 데이터 중복성 또한 증가 함에 따라서 데이터 독립성의 필요성이 대두된 것이다.

이러한 데이터 독립성이 확보되면 다음과 같은 효과를 얻을 수 있다.


- 각 View의 독립성을 유지하고 계층별 View에 영향을 주지 않고 변경이 가능한다.

- 단계별 스키마에 따라 데이터 정의어와 데이터 조작어가 다름을 제공한다.



2-5-2. 데이터베이스의 3단계 구조


데이터 독립성을 가지는 모델은 다음과 같이 외부단계, 개념적단계, 내부적 단계로 서로 간섭되지 않는 모델을 제시한다.



- 외부 단계(외부 스키마, External Schema)

View 단계 여러 개의 사용자 관점으로 구성한다. 즉, 개개인의 사용자 단계로서 개개인의 사용자가 보는 개인적인 DB 스키마이다. 이에 따라 DB의 개개인 사용자나 응용 프로그래머가 접근하는 DB를 정의한다.


- 개념적 단계(개념 스키마, Conceptual Schema)

개념단계 하나의 개념적 스키마로 구성되는 모든 사용자 관점을 통합한 조직 전체의 DB를 기술하는 것이다. 모든 응용시스템들이나 사용자들이 필요로 하는 데이터를 통합한 조직 전체의 DB를 기술한 것으로 DB에 저장되는 데이터와 그들간의 관계를 표현하는 스키마이다.


- 내부적 단계(내부 스키마, Internal Schema)

DB가 물리적으로 저장된 형식을 나타낸다. 물리적 장치에서 데이터가 실제적으로 저장되는 방법을 표현한다.



2-6. 데이터 모델링의 3가지 요소


데이터 모델링을 구성하는 중요한 개념 3가지가 있는데 이것은 데이터 모델에 대한 이해의 근간이 되므로 반드시 기억할 필요가 있다.


1. 업무가 관여하는 어떤 것(Things)

2. 어떤 것이 가지는 성격(Attributes)

3. 업무가 관여하는 어떤 것 간의 관계(Relationship)


위 3가지는 데이터 모델링을 완성해가는 개념이며 결국 우리가 앞에서 공부했던 엔터티, 속성, 관계를 나타낸다.



2-7. 좋은 데이터 모델의 요소


그럼, 데이터 모델링을 통해 도출된 데이터 모델에 대한 객관적 평가는 어떠한 것을 중심으로 진행될까? 일반적으로 좋은 데이터 모델을 평가하기 위해서는 다음과 같은 요소들을 고려한다.


2-7-1. 완전성(Completeness)

업무에서 필요로 하는 모든 데이터가 데이터 모델에 정의되어 있는지를 확인하는 요소이다. 사실상 데이터 모델을 검증하기 위해 제일 먼저 확인이 이루어져야 하는 요소이다. 


2-7-2. 중복배제(Non-Redundancy)

하나의 데이터베이스에 동일한 사실은 반드시 한번만 기록되어야 한다. 데이터에 대한 중복이 있다면 필요하지 않은 데이터에 대한 관리가 필요하다. 즉 저장공간의 낭비, 데이터 유지를 위한 비용 지불, 데이터의 일관성을 유지하기 위한 추가적인 조치 등이 대표적으로 낭비되는 비용이다.


2-7-3. 업무규칙(Business Rules)

데이터 모델링 과정을 통해 도출되고 규명되는 수많은 업무규칙은 데이터 모델에 잘 표현되어야 하고, 이를 해당 데이터 모델을 활용하는 모든 사용자가 공유할 수 있도록 제공되어야 한다. 특히, 데이터 아키텍처에서 언급되는 논리 데이터 모델에서 이러한 요소들이 포함되어야 하는 점은 매우 중요하다.


2-7-4. 데이터 재사용(Data Reusability)

데이터의 통합성과 독립성에 대해서 충분히 고려가 된다면 데이터 재사용성을 향상시킬 수 있다. 데이터 재사용성을 높임으로써 시스템 유지보수 뿐 아니라, 신규 시스템을 구축하는 데에 있어서도 매우 유리하게 작용될 수 있다.


2-7-5. 의사소통(Communication)

데이터 모델은 대상으로 하는 업무를 데이터 관점에서 분석하고 이를 설계하여 나오는 최종 산출물이다. 그리고 그 과정에서는 자연스럽게 많은 업무 규칙들이 도출된다. 그러한 업무 규칙들에 대해서 해당 정보시스템을 운용, 관리하는 많은 관련자들이 설계자가 정의한 업무 규칙들을 동일한 의미로 받아들이고 정보시스템을 활용할 수 있도록 의사소통 역할을 하는 것이 데이터 모델이다.


2-7-6. 통합성(Integration)

물론 성능 등의 부가적인 목적때문에 의도적으로 데이터를 중복시키는 경우는 존재할 수 있다. 그러한 경우가 아니라면 동일한 데이터가 다양한 곳에 존재하는 것은 또 하나의 낭비일 수 있다. 따라서 데이터 모델링을 진행하는 과정에 있어 동일한 성격의 데이터를 한 번만 정의함으로써 공유 데이터에 대한 구조를 여러 업무 영역에서 공동으로 사용하기 용이하도록 해야 한다.



Q. 데이터 모델링 관련 문제


1. 다음 설명 중 데이터 모델링이 필요한 주요 이유로 가장 부적절한 것은?


⑴ 업무정보를 구성하는 기초가 되는 정보들에 대해 일정한 표기법에 의해 표현한다.

⑵ 분석된 모델을 가지고 데이터베이스를 생성하여 개발 및 데이터관리에 사용하기 위한 것이다.

⑶ 데이터베이스를 구축하기 위한 용도를 위해 데이터모델링을 수행하고 업무에 대한 설명은 별도의 표기법을 이용한다.

 데이터모델링 자체로서 업무의 흐름을 설명하고 분석하는 부분에 의미를 가지고 있다.




2. 다음 중 ANSI-SPARC에서 정의한 3단계구조(three-level architecture)에서 아래 내용이 설명하는 스키마구조로 가장 적절한 것은?


- 모든 사용자 관점을 통합한 조직 전체 관점의 통합적 표현

- 모든 응용시스템들이나 사용자들이 필요로 하는 데이터를 통합한 조직 전체의 DB를 기술한 것으로 DB에 저장되는 데이터와 그들간의 관계를 표현하는 스키마


⑴ 외부스키마(External Schema)

⑵ 개념스키마(Conceptual Schema)

⑶ 내부스키마(Internal Schema)

⑷ 논리스키마(Logical Schema)




추가적으로 궁금한 사항이나 잘 이해가 되지 않는 부분들은 이메일 또는 카카오톡으로 연락주시면 답변드리겠습니다.

블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요



안녕하세요. 문범우입니다.

이번 포스팅에서는 DataBase에서 데이터 모델 개념에 속하는 관계(Relationship)와 식별자(Identifiers)에 대해서 알아보도록 하겠습니다.




1. 관계(Relationship)


1-1. 관계(Relationship)란?


사전적으로 정의했을 때, 관계란 상호 연관성이 있는 상태라고 할 수 있다. 이를 우리가 학습하고자 하는 데이터 모델의 개념에서 생각하면, 엔터티의 인스턴스 간 논리적인 연관성이라고 생각할 수 있고 보다 구체적으로는, 존재의 형태로서나 행위로서 서로에게 연관성이 부여된 상태라고 할 수 있다. 

이러한 관계는 엔터티와 엔터티 간 연관성을 표현하기 때문에 특정 엔터티의 정의에 따라 영향을 받기도 하고, 속성 정의 및 관계 정의에 따라서도 다양하게 변경될 수 있다.



1-2. 관계의 패어링(Relationship Paring)


관계에 대해서 생각할 때 유의해야할 점이 있다.

위에서 설명한 관계의 정의를 통해 고려해볼 때, 엔터티 안의 인스턴스가 보두 동일한 관계를 가지고 있다고 생각할 수 있지만, 엔터티 안의 인스턴스는 개별적으로 관계를 가지게 되고 이것의 집합을 관계로 표현한다.

그리고 이때, 각각의 엔터티의 인스턴스들이 자신과 관련된 인스턴스들과의 관계를 어커런스로 참여하는 형태를 관계 패어링(Relationship Paring)이라고 한다.



즉, 위의 그림과 같이 학생 엔터티와 수업 엔터티가 있다고 생각해보자. 이때 학생 엔터티의 인스턴스인 김철수와 김길동은 각각 수업 엔터티의 인스턴스인 수학과 영어에 대해 서로 다른 관계를 가지고 있다. 김철수 인스턴스는 수학과 영어 인스턴스 모두와 관계를 가지고 있으며 김길동 인스턴스는 영어 인스턴스와 관계를 가지고 있다. 이렇게 각 인스턴스간 관계가 설정되어 있는 어커런스를 관계 패어링이라고 하며, 이러한 관계 패어링의 집합을 관계라고 한다.



1-3. 관계의 분류


1-3-1. 연결 목적에 따른 분류


아래와 같이 '존재에 의한 관계', '행위에 의한 관계' 두개로 나뉘어지는데 이는 어떠한 목적으로 관계가 연결되었느냐를 기준으로 한다.


- 존재에 의한 관계

예를 들어, '학부/과' 라는 엔터티와 '학생'이라는 엔터티가 존재한다고 가정하자. 이때 '학생' 엔터티의 특정 인스턴스는 언제든지 '학부/과' 엔터티의 특정 인스턴스에 속해있을 것이다. 이는 어떠한 이벤트나 액션, 행위에 의한 것이 아니라 단순히 소속되어 있기 때문에 나타나는 관계이다. 이러한 경우를 존재에 의한 관계라고 한다.


- 행위에 의한 관계

예를 들어, '손님'이라는 엔터티와 '주문'이라는 엔터티가 있다고 가정해보자. 각 엔터티의 특정 인스턴스 끼리는 관계가 발생하기 위해 '손님'이라는 엔터티의 인스턴스가 특정 행위를 해야한다. 이러한 관계를 행위에 의한 관계라고 이야기를 한다.



1-4. 관계의 표기법


관계를 표기할 때에는 아래와 같이 3가지 개념에 대해서 함께 표현해준다.



1-4-1. 관계명(Membership)


관계명은 엔터티가 관계에 참여하는 형태를 지칭한다. 관계는 2개의 엔터티에 의해 발생되므로, 하나의 관계는 2개의 관계명을 가지게 되며, 각각의 관게명에 따라서 하나의 관계가 두가지 관점으로 표현될 수 있다.

이때, 엔터티에서 관계가 시작되는 쪽을 관계시작점이라고 부르고 관계가 끝나는 쪽을 관계끝점이라고 한다. 관계명을 지을 때는 아래와 같은 명명규칙을 따른다.


- 애매한 동사를 피한다. 예를 들어 '관련이 있다', '관계된다' 등은 구체적이지 않아 두 엔터티간에 어떤 행위/상태가 존재하는지 파악하기 어렵다.


- 현재형으로 표현한다. 예를 들어, '주문을 했다', '신청할 것이다'라는 식의 표현은 사용하지 않는다. 대신 '주문 한다', '신청 한다' 와 같이 표현한다.



1-4-2. 관계차수(Cardinality)


관계차수란, 관계에 참여하는 두 엔터티의 참여자수를 이야기한다. 일반적으로 1:1, 1:M, M:N으로 나타낸다. 즉 관계에 하나만 참여하는지, 아니면 그 이상(2개 이상)이 관계에 참여하는지를 파악하는 것이 중요하다.

각각의 관계에 대한 IE 표기법은 다음과 같다.


1-4-3. 관계선택사양(Optionality)


관계선택사양이라는 것은 엔터티가 항상 관계에 참여하는지, 아니면 선택적으로 관계에 참여할 수 있는 것인지를 의미한다. 이때 항상 관계에 참여하는 것을 필수 참여(Mandatory Membership)이고 선택적으로 관계에 참여하는 것을 선택 참여(Optional Membership)이라고 한다.



위와 같이 학생 엔터티와 수업 엔터티가 있을 때, 학생 엔터티는 수업 엔터티와 관계가 있을수도 있고 없을수도 있기때문에 학생 엔터티를 기준으로 학생-수업 관계는 선택참여가 된다. 따라서 위와 같이 동그라미표시를 한다. 반대로 수업 엔터티는 학생 엔터티가 관계가 필수적이기 때문에 수업 엔터티를 기준으로 수업-학생 관계는 필수 참여가 되고 이때에는 아무런 표시를 하지 않는다.

(학생이 듣지 않는 수업에 대해서는 고려하지 않았다.)



1-5. 관계 체크사항


두개의 엔터티 사이에서 관계를 정의할 때에는 다음과 같은 사항들을 체크해 보아야 한다.


- 두 개의 엔터티 사이에 관심있는 연관규칙이 존재하는가?

- 두 개의 엔터티 사이에 정보의 조합이 발생되는가?

- 업무기술서, 장표에 관계연결에 대한 규칙이 서술되어 있는가?

- 업무기술서, 장표에 관계연결을 가능하게 하는 동사(Verb)가 있는가?



Q. 관계 관련 문제


1. 다음 중 관계에 대한 설명으로 가장 부적절한 것은?


⑴ 관계는 존재적 관계와 행위에 의한 관계로 나누어볼 수 있다.

⑵ 관계의 표기법은 관계명, 관계차수, 식별성의 3가지 개념을 사용한다.

⑶ 부서와 사원 엔터티 간의 '소속' 관계는 존재적 관계의 사례이다.

⑷ 주문과 배송 엔터티 간의 '배송근거' 관계는 행위에 의한 관계의 사례이다.




2. 다음 중 두 개의 엔터티 사이에 정의한 관계를 체크하는 사항으로 가장 부적절한 것은?


⑴ 두 개의 엔터티 사이에 관심 있는 연관규칙이 존재하는가?

⑵ 두 개의 엔터티 사이에 정보의 조합이 발생되는가?

⑶ 업무기술서, 장표에 관계연결에 대한 규칙이 서술되어 있는가?

⑷ 업무기술서, 장표에 관계연결을 가능하게 하는 명사가 있는가?





2. 식별자(Identifiers)


2-1. 식별자(Identifiers)란?


우리는 앞에서 인스턴스들의 집합(조합)이 엔터티라고 했다. 그럼, 엔터티내에서 특정 인스턴스를 구별하는 방법은 무엇일까? 이를 위해서 식별자가 존재한다. 즉, 여러 개의 인스턴스를 담고 있는 엔터티에서 인스턴스를 구별하기 위한, 즉 엔터티를 대표하는 속성을 의미하며 하나의 엔터티에서는 반드시 하나의 유일한 식별자가 존재해야 한다. 

데이터베이스 공부를 했던 사람이라면 키(Key)와 식별자를 동일하게 생각할 수 있는데, 식별자는 업무적으로 구분이 되는 정보이므로 논리 데이터 모델링 단계에서 사용하는 용어이며, 키(Key)는 데이터베이스에서 테이블에 접근을 하기 위한 것으로 물리 데이터 모델링 단계에서 사용하는 것으로 약간의 차이가 존재한다.



2-2. 식별자의 특징


여기서 알아보는 식별자의 특징에서는 사실상 주 식별자를 기준으로 한다. 이후에 알아볼 내용이지만 주 식별자 이외에 외부식별자라는 개념도 존재하는데, 외부식별자의 경우 주식별자의 특징과 일치하지 않으며 참조무결성 제약조건에 따른 특징을 갖는다.

그럼 주 식별자가 가지는 특징은 다음과 같다.


- 유일성

주식별자에 의해 엔터티내에 모든 인스턴스들을 유일하게 구분할 수 있어야 함


- 최소성

주식별자를 구성하는 속성의 수는 유일성을 만족하는 최소의 수가 되어야 함


- 불변성

주식별자가 한 번 특정 엔터티에 지정되면 그 식별자의 값은 변하지 않아야 함


- 존재성

주식별자가 지정되면 반드시 데이터 값이 존재 해야함(Null값 안됨)



2-3. 식별자의 분류


2-3-1. 대표성 유무에 따른 분류


- 주식별자(Primary Identifier)

엔터니 내에서 각 어커런스를 구분할 수 있는 구분자이며, 타 엔터티와 참조관계를 연결할 수 있는 식별자


- 보조식별자(Alternate Identifier)

엔터티 내에서 칵 어커런스를 구분할 수 있는 구분자이지만 대표성을 가지지 못해 참조관계 연결을 못함



2-3-2. 스스로 생성되었는지에 따른 분류


- 내부식별자

엔터티 내부에서 스스로 만들어지는 식별자


- 외부식별자(Foreign Identifier)

타 엔터티와의 관계를 통해 타 엔터티로부터 받아오는 식별자



2-3-3. 단일 속성인지에 따른 분류


- 단일식별자(Single Identifier)

하나의 속성으로 구성된 식별자


- 복합식별자(Composit Identifier)

둘 이상의 속성으로 구성된 식별자



2-3-4. 업무적 의미가 있는가에 따른 분류


- 본질식별자

업무에 의해 만들어지는 식별자


- 인조식별자

업무적으로 만들어지지는 않지만 원조식별자가 복잡한 구성을 가지고 있기 때문에 인위적으로 만든 식별자



2-4. 주식별자 도출기준


데이터 모델링에 있어서 주식별자를 도출하는 것은 중요한 작업이다. 주식별자를 도출하기 위한 기준은 아래와 같다.


- 해당 업무에서 자주 이용되는 속성을 주식별자로 정의한다.

- 명칭, 내역 등과 같이 이름으로 기술되는 것들은 가능하면 주식별자로 지정하지 않는다.

- 복합으로 주식별자를 구성할 경우 너무 많은 속성이 포함되지 않도록 한다.



2-5. 비식별자 관계(Non-Identifying Relationship)


부모 엔터티로부터 속성을 받았지만 이를 자식 엔터티의 주 식별자로 사용하지 않고 일반적인 속성으로 사용하게 되는 경우가 있는데 이러한 경우를 비식별자 관계(Non-Identifying Relationship)라고 한다. 다음의 네가지 경우에 대해서 비식별자 관계에 의한 외부속성을 생성한다.


1) 자식엔터티가 부모엔터티로부터 받은 속성이 반드시 필수 값이 아니기 때문에 부모 없는 자식이 생성될 수 있는 경우


2) 엔터티별로 데이터의 생명주기(Life Cycle)를 다르게 관리할 경우. 예를 들어, 부모 엔터티가 자식 엔터티보다 먼저 소멸되는 경우 등을 말한다.


3) 여러개의 엔터티가 하나의 엔터티로 통합되어 표현되었는데 각각의 엔터티가 별도의 관계를 가질 때


4) 자식엔터티에 주식별자로 사용하여도 되지만, 자식엔터티에서 별도의 주식별자를 생성하는 것이 더 유리하다고 판단될 때



2-6. 식별자관계와 비식별자관계 모델링


2-6-1. 비식별자관계 선택 프로세스


식별자 관계를 파악하는데에 있어서 중요한 한가지는 비식별자관계를 파악하는 것이다. 비식별자관계를 파악할때에 있어서 다음과 같은 흐름에 따라 선정한다면 합리적으로 비식별자관계를 설정할 수 있다.




2-6-2. 식별자관계와 비식별자관계 비교


항목

식별자관계

비식별자관계

목적

강한 연결관계 표현

약한 연결관계 표현

자식 주식별자

영향

자식 주식별자의 구성에 포함됨

자식 일반 속성에 포함됨

표기법

실선 표현

점선 표현

연결

고려사

- 반드시 부모엔터티 종속

- 자식 주식별자구성에 부모 주식별자포함 필요

- 상속받은 주식별자속성을 타 엔터티에 이전 필요

- 약한 종속관계

- 자식 주식별자구성을 독립적으로 구성

- 자식 주식별자구성에 부모 주식별자 부분 필요

- 상속받은 주식별자속성을 타 엔터티에 차단 필요

- 부모쪽의 관계참여가 선택관계




Q. 식별자 관련 문제


1. 다음 중 아래에서 엔터티 내에 주식별자를 도출하는 기준을 묶은 것으로 가장 적절한 것은?


가. 해당 업무에서 자주 이용되는 속성을 주식별자로 지정한다.

나. 명칭, 내역 등과 같이 이름으로 기술되는 것들을 주식별자로 지정한다.

다. 복합으로 주식별자를 구성할 경우 너무 많은 속성을 포함하지 않도록 한다.

라. 자주 수정되는 속성을 주식별자로 지정한다.


⑴ 가, 나

⑵ 가, 다

⑶ 다, 라

⑷ 나, 라




2. 다음 중 비식별자 관계로 연결하는 것을 고려해야 하는 경우로 가장 부적절한 것은?


⑴ 부모엔터티에 참조값이 없어도 자식엔터티의 인스턴스가 생성될 수 있는 경우

⑵ 자식쪽 엔터티의 주식별자를 부모엔터티와는 별도로 생성하는 것이 더 유리하다고 판단되는 경우

⑶ 여러 개의 엔터티를 하나로 통합하면서 각각의 엔터티가 갖고 있던 여러 개의 개별 관계가 통합되는 경우

⑷ 부모엔터티의 인스턴스가 자식 엔터티와 같이 소멸되는 경우




추가적으로 궁금한 사항이나 이해가 되지 않는 점은 언제든지 이메일 또는 카카오톡으로 연락주시면 답변드리도록 하겠습니다.

블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요



안녕하세요. 문범우입니다.

이번 포스팅에서는 Data Base에서  엔터티와 속성에 대해서 알아보도록 하겠습니다.

특히 각 개념마다 SQL 전문가 또는 SQL 개발자를 준비하시는 분들을 위한 문제를 함께 두었으니 공부를 하시며 문제들을 확인하면 보다 좋은 학습이 될 것 입니다.



1. 엔터티(Entity)


1-1. 엔터티(Entity)란?


데이터 베이스의 개념 중에서도 데이터 모델에 대해 공부를 시작할 때 제일 먼저 나오는 개념이 '엔터티(Entity)' 이다.

엔터티는 쉽게 말해 실체, 객체라고 생각할 수 있다.

일반적으로 엔터티를 정의하는 개념들을 정리하여 나타내면 다음과 같이 볼 수 있다.


- 엔터티는 사람, 장소, 물건, 사건, 개념 등과 같은 명사에 해당된다.

- 엔터티는 업무상 관리가 필요한 것에 해당된다.

- 엔터티는 저장 되기 위한 어떤 것(Thing)에 해당된다.


예를 들어 학교라는 곳에선 과목이라는 엔터티가 존재할 수 있다.

그리고 엔터티는 인스턴스의 집합으로 나타나게 됩니다. 즉 과목이라는 엔터티가 있다면, 수학, 영어, 국어와 같은 인스턴스가 과목이라는 엔터티에 포함되는 것이다.

이때 엔터티는 자신이 가지고 있는 인스턴스를 설명할 수 있는, 나타낼 수 있는 속성(Attribute)를 가지게 된다. 앞에서 이야기한 수학, 영어, 국어와 같은 인스턴스가 존재한다면 이들은 과목이라는 엔터티에서 이름이라는 속성을 가지고 있는 것이죠. 속성에 대해서는 엔터티를 알아본 후에 보다 자세히 알아보자.



1-2. 엔터티의 특징


엔터티는 일반적으로 다음과 같은 특징을 가지고 있다. 물론 아래와 같은 특징을 지니지 않은 경우도 있을 수 있지만 일반적으로 아래의 특징을 지니지 않으면 적절하지 않은 엔터티일 확률이 높다.


- 반드시 엔터티가 사용되는 곳의 업무에서 필요하며 관리하고자 하는 정보

- 엔터티가 포함하는 인스턴스에 대해 유일한 식별자로 식별이 가능해야 함

- 엔터티는 지속적으로 존재하는 두개 이상의 인스턴스들의 조합이어야 함

- 엔터티는 반드시 속성을 지녀야 함

- 엔터티는 업무 프로세스에 의해서 이용되어야 함

- 엔터티는 다른 엔터티와 최소 한 개 이상의 관계가 있어야 함



1-3. 엔터티의 분류


엔터티는 각각의 성격에 의해, 실체유형(유무형)에 따라 구분하거나, 엔터티의 발생시점에 의해 분류될 수 있다.


1-3-1. 실체유형(유무형)에 따른 분류


- 유형 엔터티(Tangible Entity)

물리적인 형태가 존재하는 엔터티이며 안정적이고 지속적으로 활용되는 엔터티이다.


- 개념 엔터티(Conceptual Entity)

물리적인 형태는 존재하지 않고 관리해야 할 개념적인 정보로 구분이 되는 엔터티이다.


- 사건 엔터티(Event Entity)

업무를 수행함에 따라 발생되는 엔터티이다.



1-3-2. 발생시점에 따른 분류.


- 기본/키 엔터티(Fundamental/Key Entity)

해당 업무에 원래 존재하는 정보로 다른 엔터티와의 관계에 의해 발생 또는 생성되지 않고 독립적으로 존재하는 엔터티이다. 이는 독립적으로 생성이 가능하며 다른 엔터티의 부모역할을 한다.


- 중심 엔터티(Main Entity)

기본 엔터티로 부터 발생되며 업무에 있어서 중심적인 역할을 한다. 일반적으로 데이터 양이 많으며 다른 엔터티와의 관계를 통해 행위 엔터티를 생성한다.


- 행위 엔터티(Active Entity)

두 개이상의 부모엔터티로 부터 주로 발생되고, 자주 엔터티의 내용이 바뀌거나 데이터양이 증감한다. 분석초기 단계보다는 상세 설계단계나 프로세스와 상관모델링을 진행하면서 도출될 수 있다.



1-4. 엔터티의 명명(Naming)


엔터티의 이름을 정하는 데에 있어서는 다음과 같은 원칙을 지켜야 한다.


- 가능하면 현업업무에서 사용하는 용어를 사용한다.

- 가능하면 약어를 사용하지 않는다.

- 단수 명사를 사용한다.

- 모든 엔터티를 통틀어서 유일한 이름을 가져야 한다.

- 엔터티의 생성의미대로 이름을 부여한다.



Q. 엔터티 관련 문제


1. 다음 중 아래 시나리오에서 엔터티로 적합한 것은?


S병원은 여러 명의 환자가 존재하고 각 환자에 대한 이름, 주소 등을 관리해야 한다.

(단, 업무 범위와 데이터의 특성은 상기 시나리오에 기술되어 있는 사항만을 근거하여 판단해야 한다.)


⑴ 병원

⑵ 환자

⑶ 이름

⑷ 주소




2. 다음 중 엔터티의 특징으로 가장 부적절한 것은?


⑴ 속성이 없는 엔터티는 있을 수 없다. 엔터티는 반드시 속성을 가져야 한다.

⑵ 객체지향의 디자인 패턴에는 싱글턴패턴이 있어 하나의 인스턴스를 가지는 클래스가 존재하듯, 엔터티는 한 개의 인스턴스를 가지는 것만으로도 충분한 의미를 부여할 수 있다.

⑶ 엔터티는 다른 엔터티와 관계가 있을 수 밖에 없다. 단, 통계성 엔터티나, 코드성 엔터티의 경우 관계를 생략할 수 있다.

⑷ 데이터로서 존재하지만 업무에서 필요로 하지 않으면 해당 업무의 엔터티로 성립될 수 없다.




3. 다음 중 다른 엔터티로부터 주식별자를 상속받지 않고 자신의 고유한 주식별자를 가지며 사원, 부서, 고객, 상품, 자재 등이 예가 될 수 있는 엔터티로 가장 적절한 것은?


⑴ 기본 엔터티(키 엔터티)

⑵ 중심 엔터티(메인엔터티)

⑶ 행위 엔터티

⑷ 개념 엔터티




2. 속성(Attribute)


2-1. 속성(Attribute)란?


속성의 사전적 의미는, 어떤 사물의 성질이나 특징, 그것이 없다면 실체를 생각 또는 표현할 수 없는 것으로 정의할 수 있다.

데이터 모델의 관점에서 속성은, 인스턴스로 관리하고자 하는 의미상 더 이상 분리되지 않는 최소의 데이터 단위로 정의할 수 있다. 

즉, 속성이란 의미상 더 이상 분리되지 않으며, 엔터티를 설명하는 요소이며 인스턴스의 구성요소이다.



2-2. 속성의 특징


속성 또한 엔터티와 같이 다음과 같은 성질을 가지고 있으며, 이러한 성질을 지니지 않는다면 적절하지 못한 속성일 확률이 높다.


- 엔터티와 마찬가지로 반드시 해당 업무에서 필요하고 관리하고자 하는 정보이어야 한다.

- 정규화 이론에 근간하여 정해진 주 식별자에 함수적 종속성을 가져야 한다.

쉽게 말해, 다양하게 존재하는 인스턴스들에 대해 유일하게 구별할 수 있는 주식별자를 통해서 식별될 수 있어야 한다.

- 하나의 속성에는 단 한개의 값만을 가진다.



2-3. 엔터티, 인스턴스, 속성, 속성값의 관계


엔터티에는 두 개 이상의 인스턴스가 존재한다. 그리고 각각의 엔터티에는 고유의 성격을 표현하는 속성정보를 두 개 이상 갖는다. 

분석단계에서는 엔터티 내에 존재하는 여러 개의 인스턴스가 가지는 동일한 성격을 파악하여 이에 이름을 부여하여 엔터티의 속성으로 결정하는 작업이 필요하다. 또한 하나의 속성은 하나의 인스턴스에만 존재할 수 있으며, 속성은 스스로가 또 다른 속성을 가질 수 없고 속성에 대해 어떠한 관계로 기술할 수 없다. 그리고 각 인스턴스는 하나의 속성에 대해 하나의 속성 값만 가질 수 있다.

이를 정리하면 다음과 같다.


- 한 개의 엔터티는 두 개 이상의 인스턴스의 집합이다.

- 한 개의 엔터티는 두 개 이상의 속성을 가진다.

- 한 개의 속성은 한 개의 속성 값을 가진다.



2-4. 속성의 분류


2-4-1. 속성의 특성에 따른 분류


- 기본 속성(Basic Attribute)

업무 분석을 통해 바로 정의한 속성을 기본속성이라고 한다. 엔터티에 있어서 가장 일반적이고 많은 속성을 차지한다. 하지만 코드성 데이터, 엔터티를 식별하기 위해 부여된 일련번호, 그리고 다른 속성을 계산하거나 영향을 받아 생성된 속성등은 기본속성이 아니다.


- 설계 속성(Designed Attribute)

업무상 필요한 데이터 이외에 데이터 모델링을 위해, 업무를 규칙화하기 위해 새로 만들어지거나 변형된 속성을 설계 속성이라고 한다. 일반적으로 코드성 속성은 기존의 속성을 업무상 필요에 의해 변형하여 만든 설계 속성이다. 또한 일련번호와 같은 속성 또한 단일한 식별자를 부여하기 위해 모델 상에서 새롭게 정의하는 설계속성이다.


- 파생 속성(Derived Attribute)

다른 속성에 영향을 받아 발생하는 속성은 파생 속성이다. 일반적으로 계산된 값들이 이에 해당된다. 파생 속성은 가급적 적게 정의하는 것이 좋다.



2-4-2. 엔터티 구성방식에 따른 분류


- PK(Primary Key) 속성

엔터티를 유일하게 구분할 수 있는 속성을 PK 속성이라고 한다.


- FK(Foreign Key) 속성

다른 엔터티와의 관계에 있어서 포함된 속성을 FK 속성이라고 한다.


- 일반 속성

엔터티에 포함되어 있고, PK 또는 FK에 포함되지 않는 속성을 일반 속성이라고 한다.



2-4-3. 세부 의미 유무에 따른 분류


- 단순 속성(Simple Attibute)

나이, 성별과 같은 데이터는 더 이상 다른 속성들로 구성될 수 없는 단순한 속성이므로 단순 속성이라고 한다.


- 복합 속성(Composite Attribute)

주소 속성에 대해서는 시, 구, 동, 번지와 같이 여러 세부 속성들로 구성될 수 있는데 이때 주소 속성과 같은 것들을 복합 속성이라고 한다.



2-5. 도메인(Domain)


각 속성은 무한정적인 값을 갖는 것이 아니라 그 범위가 지정된다. 이 때 속성의 값이 가질 수 있는 범위를 그 속성의 도메인이라고 한다. 따라서 속성 값이 가질 수 있는 데이터 타입과 크기 그리고 추가적인 제약사항이라고 생각할 수 있다.



2-6. 속성의 명명(Naming)


속성에 대해 이름을 부여하는데에 있어서는 아래와 같은 원칙이 존재한다.


- 해당 업무에서 사용하는 이름을 부여한다.

- 서술식 속성명은 사용하지 않는다.

- 약어사용은 가급적 제한한다.

- 전체 데이터 모델에서 유일성을 확보하는 것이 좋다.



Q. 속성 관련 문제


1. 다음 중 속성에 대한 설명으로 가장 부적절한 것은?


⑴ 엔터티에 대한 자세하고 구체적인 정보를 나타낸다.

⑵ 하나의 엔터티는 두 개 이상의 속성을 갖는다.

⑶ 하나의 인스턴스에서 각각의 속성은 하나 이상의 속성값을 가질 수 있다.

⑷ 속성도 집합이다.




2. 다음 중 데이터를 조회할 때 빠른 성능을 낼 수 있도록 하기 위해 원래 속성의 값을 계산하여 저장할 수 있도록 만든 속성으로 가장 적절한 것은?


⑴ 파생속성(Derived Attribute)

⑵ 기본속성(Basic Attribute)

⑶ 설계속성(Designed Attribute)

⑷ PK속성(Primary Key Attribute)




3. 다음 중 아래 설명이 나타내는 데이터모델의 개념으로 가장 적절한 것은?


주문이라는 엔터티가 있을 때 단가라는 속성 값의 범위는 100에서 10,000 사이의 실수 값이며 제품명이라는 속성은 길이가 20자리 이내의 문자열로 정의할 수 있다.


⑴ 시스템카탈로그(System Catalog)

⑵ 용어사전(Word Dictionary)

⑶ 속성사전(Attribute Dictionary)

⑷ 도메인(Domain)




추가적으로 궁금한 사항이나, 이해가 되지 않는 점은 언제든지 이메일 또는 카톡으로 연락주시면 빠른 답변드릴 수 있도록 하겠습니다.

블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요


안녕하세요. 문범우입니다.

이번에는 MSSQL에서 특정한 문법을 사용하는 내용이 아니라 특정 칼럼 값만 다른 여러개의 행을 하나의 행으로 합쳐서 나타내는 실습을 진행해보도록 하겠습니다.



0. 데이터 세팅


먼저 실습을 위해 아래와 같이 데이터를 세팅합니다. 테이블 이름은 USER_ANSWER로 만들었습니다.




세팅된 테이블을 전체 SELECT를 하면 다음과 같습니다.



위의 데이터를 아래와 같은 상황으로 가정합니다.


현재 USER_ID 값이 0001, 0002, 0003 으로 총 3명이 존재하며, 각각은 모두 Q01 부터 Q05까지의 문제에 대해 답변을 선택하여 해당 데이터가 테이블에 존재하는 것입니다.

이때 각 문제들은 중복으로 답을 체크할 수 있습니다. 

USER_ID값이 0001인 데이터를 보면 모두 하나의 문제에 하나의 답이 존재합니다.

하지만 USER_ID값이 0002인 데이터를 보면 Q02문제에 대해 ANSWER_NUM이 5인 것과 3인 것으로 2개가 존재합니다.

마찬가지로 USER_ID가 0003인 데이터를 보면 Q01문제에 대해 서로 다른 ANSWER_NUM값이 존재합니다.


이러한 데이터를 우리는 아래와 같이 나타내고자 합니다.



USER_ID가 0002나 0003이었던 데이터에 대해서 Q02나 Q01에 콤마를 이용해 값을 합쳐서 보여주었습니다. 그리고 이를 좀 더 보기좋게 피봇을 이용하였습니다.

위와 같이 나타내기 위해 만드는 쿼리에 대해 하나씩 진행해보도록 하겠습니다.



1. 특정 칼럼 값만 다른 여러개의 행을 하나의 행으로 합치기


추후 우리는 GROUP BY를 이용해서 다수의 행을 하나의 행으로 합쳐줄 것인데, 이를 위해 ANSWER_NUM을 나눠주도록 합니다. 데이터를 살펴보았을때 선택되는 ANSWER는 1부터 5까지 존재하므로, 컬럼 이름을 A1 ~ A5로 하여 나누어 줍니다.




그리고 위 처럼 만들어진 데이터에서 USER_ID와 QUESTION_NUM을 기준으로 GROUP BY를 하여 동일한 USER_ID의 동일한 QUESTION_NUM에 대해 하나의 행으로 만들어 줍니다. 그리고 추후 사용을 위해 각 ANSWER 값에 콤마를 붙여주도록 합니다.





이렇게 데이터가 형성되었다면 A1 ~ A5로 나누었던 컬럼을 다시 합쳐주도록 합니다. 이때 합쳐지면서 각 값의 맨 뒤에 존재하는 콤마를 제거하기 위해 LEFT 함수를 사용합니다.





이렇게 하였다면 사실상 특정 컬럼 값만 다른 로우들에 대해 합치는 과정은 마무리가 됩니다. 마지막으로 이를 좀 더 보기좋게 하기 위해 PIVOT을 이용하여 정리하면 다음과 같이 됩니다.





SQL 쿼리 중 비효율적인 부분이 있는 부분에 대해서 지적해주시면 감사하겠습니다. 추가적으로 궁금하신 점은 언제든지 댓글이나 이메일, 카카오톡으로 연락주시면 답변드리도록 하겠습니다.



블로그 이미지

Tigercow.Door

Back-end / Python / Database / AI / Algorithm / DeepLearning / etc

댓글을 달아 주세요