반응형

파이썬에서 동적 속성과 프로퍼티(dynamic attributes and properties)는 객체 지향 프로그래밍에서 중요한 개념으로, 객체의 속성을 더 유연하고 강력하게 관리할 수 있도록 도와줍니다. 이 두 가지 개념을 이해하면, 더 효율적이고 유지보수하기 쉬운 코드를 작성할 수 있습니다. 아래에 각각의 개념을 자세히 설명하겠습니다.

1. 동적 속성 (Dynamic Attributes)

파이썬에서는 객체에 동적으로 속성을 추가하거나 제거할 수 있습니다. 이것은 파이썬의 유연한 클래스 구조 덕분에 가능한데, 다른 많은 프로그래밍 언어에서는 클래스에 정의된 속성만을 사용할 수 있는 경우가 많습니다.

 

동적 속성의 사용 사례

동적 속성은 객체의 속성을 런타임에 결정해야 하거나, 객체가 다루는 데이터 구조가 매우 유동적일 때 유용합니다. 예를 들어, JSON 응답에서 키를 동적으로 객체 속성으로 변환할 때 사용할 수 있습니다.

 

2. 프로퍼티 (Properties)

프로퍼티는 파이썬에서 제공하는 특수한 속성으로, 속성에 접근할 때 특정한 동작을 수행할 수 있게 해줍니다. 예를 들어, 속성의 값을 가져오거나 설정할 때 추가적인 로직을 수행할 수 있습니다.

 

프로퍼티의 사용 사례

프로퍼티는 다음과 같은 경우에 유용합니다:

  • 속성의 값을 가져오거나 설정할 때 검증 로직을 추가해야 할 때
  • 속성 값을 계산한 후 반환해야 할 때 (지연된 계산)
  • 속성 접근 방식을 일관되게 유지하면서 내부 구현을 변경하고 싶을 때

 

데이터 랭글링과 동적 속성의 관계

데이터 랭글링 과정에서는 데이터의 형태가 일정하지 않거나, 데이터의 구조가 런타임에 결정될 수 있습니다. 이러한 상황에서 파이썬의 동적 속성은 매우 유용하게 사용됩니다. 예를 들어, JSON이나 XML과 같은 비정형 데이터를 객체로 변환할 때, 동적 속성을 사용하면 해당 데이터를 쉽게 다룰 수 있습니다.

 

동적 속성을 이용한 데이터 랭글링의 장점

  1. 유연성: 데이터를 구조화하는 방법이 사전에 정의되지 않았을 때, 동적 속성을 사용하면 어떤 형태의 데이터도 쉽게 객체로 변환할 수 있습니다.
  2. 유지보수성: 새로운 데이터 필드가 추가되거나 변경될 때, 코드 수정이 최소화됩니다. 동적 속성을 통해 데이터를 자동으로 객체 속성으로 변환할 수 있기 때문입니다.
  3. 가독성: 동적으로 생성된 속성을 통해 데이터에 접근하는 것이, 복잡한 딕셔너리나 리스트 구조를 탐색하는 것보다 직관적이고 읽기 쉬운 코드를 작성하는 데 도움이 됩니다.

실제 활용 예시

동적 속성을 사용한 데이터 랭글링은 특히 웹 애플리케이션, API 응답 처리, 데이터 분석에서 자주 사용됩니다. 예를 들어, API 응답 데이터를 객체로 변환하여 사용하는 경우, 새로운 데이터 필드가 응답에 추가되더라도 별도의 코드 수정 없이 그 필드를 동적으로 추가하여 처리할 수 있습니다.

요약하자면, "동적 속성을 이용한 데이터 랭글링"은 파이썬의 동적 속성을 활용하여 다양한 형태의 데이터를 유연하게 다루고, 이를 통해 데이터 변환, 정제, 조작을 더 효율적으로 수행하는 방법을 의미합니다.

 

import json

class DynamicObject:
    def __init__(self, **entries):
        self.__dict__.update(entries)

# JSON 데이터를 파싱하여 파이썬 딕셔너리로 변환
json_data = '{"name": "Alice", "age": 30, "city": "New York"}'
data = json.loads(json_data)

# 동적 속성을 사용하여 객체로 변환
obj = DynamicObject(**data)

# 동적으로 추가된 속성에 접근
print(obj.name)  # 출력: Alice
print(obj.age)   # 출력: 30
print(obj.city)  # 출력: New York

 

json 파일을 원래 상태 그대로 다루다보면, 아래와 같이 번거로운 구문이 반복된다.

feed['Schedule']['speakers'][0]['name']

 

동적 속성을 이용하여 아래와 같이 사용할 수 있다면 아주 편할 것이다.

raw_feed = load()
feed = FrozenJSON(raw_feed)
print(len(feed.Schedule.speakers))
print(sorted(feed.Schedule.keys()))
print(feed.Schedule.speakers[0].name)

 

FrozenJSON class는 위와 같은 기능을 구현하고 있다.

가장 핵심은 __getattr__() method이다. 피드가 순회되면서 내포된 데이터 구조체가 차례로 FrozenJSON 포켓으로 변환된다.

from collections import abc
from loader import load

class FrozenJSON:
    '''
    점 표기법을 이용하여 JSON 객체를 순회하는
    읽기 전용 parsed class
    '''

    def __init__(self, mapping):
        self.__data = dict(mapping)

    def __getattr__(self, name):
        if hasattr(self.__data, name):
            return getattr(self.__data, name)
        else:
            return FrozenJSON.build(self.__data[name])

    @classmethod
    def build(cls, obj):
        if isinstance(obj, abc.Mapping):
            return cls(obj)
        elif isinstance(obj, abc.MutableSequence):
            return [cls.build(item) for item in obj]
        else:
            return obj


raw_feed = load()
feed = FrozenJSON(raw_feed)
print(len(feed.Schedule.speakers))
print(sorted(feed.Schedule.keys()))
print(feed.Schedule.speakers[0].name)

 

프로퍼티의 기본 사용법

프로퍼티는 property() 함수를 사용하거나, 데코레이터 @property와 그와 관련된 데코레이터(@<property_name>.setter, @<property_name>.deleter)를 사용하여 정의할 수 있습니다.

class MyClass:
    def __init__(self, value):
        self._value = value
    
    @property
    def value(self):
        return self._value
    
    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Value must be non-negative")
        self._value = new_value

    @value.deleter
    def value(self):
        del self._value

# 사용 예시
obj = MyClass(10)
print(obj.value)  # 10

obj.value = 20  # 정상적으로 값이 설정됨
print(obj.value)  # 20

obj.value = -5  # ValueError 발생

 

1. 프로퍼티에서 getter를 사용하는 경우

파이썬에서는 @property 데코레이터를 사용하여 속성 접근 시 자동으로 호출되는 getter 메서드를 정의할 수 있습니다. 이 방법은 속성에 접근할 때 obj.attribute 형태로 간단하게 사용할 수 있습니다.

장점

  1. 직관적이고 간결한 문법:
  2. 캡슐화:
  3. 속성에 접근할 때 추가 로직을 쉽게 추가:
  4. 유지보수성:

단점

  1. 은밀한 동작:
  2. 디버깅 어려움:

값을 얻기 위한 메서드를 따로 작성하는 경우

이 방법에서는 get_value()와 같은 이름으로 값을 얻기 위한 메서드를 직접 정의합니다. 이는 명시적으로 값을 얻기 위한 함수 호출임을 나타냅니다.

장점

  1. 명확성:
  2. 의도 표현:
  3. 구조적 일관성:

단점

  1. 사용의 불편함:
  2. 캡슐화의 부족:

결론: 언제 어떤 것을 사용할지

  • 프로퍼티(getter) 사용:
    • 속성 접근처럼 보이지만, 내부적으로 추가 로직이 필요한 경우.
    • 코드의 가독성과 간결성을 중시할 때.
    • 객체의 속성을 외부에 노출하면서도 캡슐화를 유지하고 싶을 때.
  • 메서드 사용:
    • 접근하는 값이 계산이나 복잡한 로직에 의해 생성되는 경우.
    • 메서드 호출임을 명확히 표현하고 싶을 때.
    • 코드의 명확성과 의도 표현이 중요한 경우.

 

프로퍼티 팩토리

"프로퍼티 팩토리(Property Factory)"는 파이썬에서 프로퍼티를 동적으로 생성하거나, 다수의 프로퍼티를 공통된 패턴에 따라 쉽게 정의하기 위해 사용하는 방법입니다. 즉, 객체의 속성을 정의할 때, 비슷한 패턴이나 규칙에 따라 다수의 속성을 자동으로 생성하고자 할 때 유용합니다.

 

def make_property(attr_name):
    def getter(self):
        return getattr(self, f"_{attr_name}")

    def setter(self, value):
        if value < 0:
            raise ValueError(f"{attr_name} cannot be negative")
        setattr(self, f"_{attr_name}", value)

    return property(getter, setter)

class MyClass:
    name = make_property('name')
    age = make_property('age')

    def __init__(self, name, age):
        self._name = name
        self._age = age

# 사용 예시
obj = MyClass("Alice", 30)
print(obj.age)  # 출력: 30

# 음수 값을 설정하려고 하면 ValueError 발생
try:
    obj.age = -5
except ValueError as e:
    print(e)  # 출력: age cannot be negative

 

 

반응형

'Computer Science > python' 카테고리의 다른 글

연산자 오버로딩  (0) 2024.07.09
추상클래스의 활용  (0) 2024.06.12
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

 

연산자 오버로딩은 파이썬에서 클래스에 특별한 메서드를 정의함으로써, 사용자 정의 객체가 기본 제공 연산자와 함께 사용될 때의 동작을 지정하는 기능입니다. 이를 통해 +, -, *, / 같은 연산자를 객체에 대해 직접 사용할 수 있습니다. 연산자 오버로딩을 통해 코드의 가독성을 높이고, 객체 지향 프로그래밍의 장점을 살릴 수 있습니다.

 

장점

  1. 코드 가독성 향상:
    • 연산자 오버로딩을 사용하면 코드가 더 직관적이고 읽기 쉬워집니다. 예를 들어, 벡터 덧셈을 vector1 + vector2로 표현할 수 있어 수학적인 표현과 일치합니다.
  2. 객체 지향 프로그래밍의 일관성:
    • 사용자 정의 객체도 기본 자료형처럼 사용할 수 있어 객체 지향 프로그래밍의 일관성을 유지할 수 있습니다. 예를 들어, Complex 클래스에서 복소수 덧셈을 정의하면, 복소수 객체를 숫자처럼 다룰 수 있습니다.
  3. 캡슐화:
    • 객체의 내부 구현을 숨기고, 연산자 오버로딩을 통해 외부에서 객체를 더 간편하게 사용할 수 있습니다. 사용자는 객체의 내부 구조를 몰라도 연산자를 통해 객체를 조작할 수 있습니다.
  4. 재사용성:
    • 연산자 오버로딩을 통해 정의된 연산은 다양한 상황에서 일관되게 사용될 수 있어 코드의 재사용성을 높입니다.

단점

  1. 가독성 저하 가능성:
    • 과도한 연산자 오버로딩은 오히려 코드의 가독성을 떨어뜨릴 수 있습니다. 연산자가 실제로 어떤 일을 하는지 명확하지 않으면, 코드를 이해하기 어려워집니다.
  2. 디버깅 어려움:
    • 연산자 오버로딩으로 인해 연산자 호출 시 실제로 어떤 메서드가 호출되는지 추적하기 어려울 수 있습니다. 이는 디버깅을 복잡하게 만들 수 있습니다.
  3. 예상치 못한 동작:
    • 연산자 오버로딩이 잘못 사용되면 예상치 못한 동작을 초래할 수 있습니다. 특히, 연산자가 일반적인 의미와 다른 동작을 수행할 경우 혼란을 초래할 수 있습니다.
  4. 유지보수 어려움:
    • 복잡한 연산자 오버로딩은 코드를 유지보수하기 어렵게 만듭니다. 시간이 지나면 코드 작성자조차도 오버로딩된 연산자의 동작을 이해하기 어려울 수 있습니다.
  5. 성능 저하:
    • 연산자 오버로딩을 남용하면 불필요한 객체 생성이나 복잡한 연산이 포함될 수 있어 성능이 저하될 수 있습니다.

 

파이썬에서 연산자 오버로딩을 위해 사용되는 특별한 메서드들(매직 메서드라고도 불림)은 다음과 같습니다:

  • __add__(self, other) - + 연산자
  • __sub__(self, other) - - 연산자
  • __mul__(self, other) - * 연산자
  • __truediv__(self, other) - / 연산자
  • __floordiv__(self, other) - // 연산자
  • __mod__(self, other) - % 연산자
  • __pow__(self, other) - ** 연산자
  • __eq__(self, other) - == 연산자
  • __ne__(self, other) - != 연산자
  • __lt__(self, other) - < 연산자
  • __le__(self, other) - <= 연산자
  • __gt__(self, other) - > 연산자
  • __ge__(self, other) - >= 연산자
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2
print(v3)  # Output: Vector(7, 10)

 

연산자 오버로딩은 같은 클래스의 인스턴스 간에도 사용될 수 있지만, 다른 클래스의 인스턴스 간에도 사용할 수 있습니다. 연산자 오버로딩 메서드에서 타입 검사를 하여 원하는 동작을 정의할 수 있습니다. 예를 들어, 서로 다른 클래스의 객체를 더하는 경우를 살펴보겠습니다.

 

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(5, 7)
v3 = v1 + v2          # 두 벡터의 덧셈
v4 = v1 + 10          # 벡터와 스칼라의 덧셈
v5 = 10 + v1          # 스칼라와 벡터의 덧셈 (__radd__ 사용)

print(v3)  # Output: Vector(7, 10)
print(v4)  # Output: Vector(12, 13)
print(v5)  # Output: Vector(12, 13)

 

위의 예제들은 길이가 다른 벡터를 더하는 다양한 방법을 보여줍니다. 어떤 방법을 사용할지는 특정 문제의 요구사항에 따라 결정하면 됩니다. 일반적으로는 길이가 다른 벡터를 더하는 것이 자연스럽지 않으므로, 명확한 의도가 없으면 에러를 발생시키는 것이 좋습니다.

 

__add__와 __radd__는 파이썬에서 연산자 오버로딩을 위해 사용되는 특별한 메서드들입니다. 이 메서드들은 + 연산자를 객체에 대해 사용할 때의 동작을 정의합니다.

 

__add__(self, other)

__add__ 메서드는 두 객체를 더할 때 호출됩니다. 즉, a + b와 같은 표현식을 평가할 때, a 객체의 __add__ 메서드가 호출됩니다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(4, 5)
v3 = v1 + v2  # v1.__add__(v2)가 호출됨
print(v3)  # Output: Vector(6, 8)

__radd__(self, other)

__radd__ 메서드는 객체가 오른쪽에 있을 때 호출됩니다. 즉, b + a와 같은 표현식에서 a 객체의 __radd__ 메서드가 호출됩니다. 이는 a + b와 b + a의 표현식에서 a 객체가 __add__를 지원하지 않는 경우, 또는 a 객체의 타입이 b 객체의 타입과 다를 때 유용합니다.

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(self.x + other.x, self.y + other.y)
        elif isinstance(other, (int, float)):
            return Vector(self.x + other, self.y + other)
        else:
            return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)  # 동일한 로직을 사용

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
result = 5 + v1  # v1.__radd__(5)가 호출됨
print(result)  # Output: Vector(7, 8)

 

복합 할당 연산자

복합 할당 연산자는 대입 연산자(=)와 다른 연산자를 결합하여 더 간결하게 표현한 연산자입니다. 이 연산자는 변수를 업데이트하는데 사용되며, 다음과 같은 다양한 형태가 있습니다:

a = 10
b = 3

a += b  # a = 13
a -= b  # a = 10
a *= b  # a = 30
a /= b  # a = 10.0
a //= b  # a = 3
a %= b  # a = 1
a **= b  # a = 1
a &= b  # a = 1
a |= b  # a = 3
a ^= b  # a = 0
a <<= b  # a = 0
a >>= b  # a = 0

 

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __iadd__(self, other):
        if isinstance(other, Vector):
            self.x += other.x
            self.y += other.y
        elif isinstance(other, (int, float)):
            self.x += other
            self.y += other
        else:
            return NotImplemented
        return self

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

# 사용 예시
v1 = Vector(2, 3)
v2 = Vector(4, 5)
v1 += v2  # v1.__iadd__(v2)가 호출됨
print(v1)  # Output: Vector(6, 8) - 원래 객체가 변경됨

 

복합 연산자는 코드의 간결성을 높이고, 반복적인 코드 작성을 줄이는 데 매우 유용합니다. 특히 데이터 처리나 반복적인 계산을 수행할 때 자주 사용됩니다. 다음은 복합 연산자를 응용한 예제로, 벡터 클래스에서 각 요소에 다른 벡터의 요소를 더하는 복합 연산(+=)을 구현하는 예입니다.

 

class Vector:
    def __init__(self, *components):
        self.components = list(components)

    def __iadd__(self, other):
        if isinstance(other, Vector):
            # 길이가 다른 경우 더 긴 벡터에 맞춰 짧은 벡터를 확장
            if len(self.components) < len(other.components):
                self.components.extend([0] * (len(other.components) - len(self.components)))
            elif len(self.components) > len(other.components):
                other.components.extend([0] * (len(self.components) - len(other.components)))
                
            for i in range(len(self.components)):
                self.components[i] += other.components[i]
        elif isinstance(other, (int, float)):
            self.components = [x + other for x in self.components]
        else:
            return NotImplemented
        return self

    def __repr__(self):
        return f"Vector({', '.join(map(str, self.components))})"

# 사용 예시
v1 = Vector(1, 2, 3)
v2 = Vector(4, 5, 6)
v1 += v2  # v1.__iadd__(v2)가 호출됨
print(v1)  # Output: Vector(5, 7, 9)

v3 = Vector(1, 2)
v4 = Vector(3, 4, 5)
v3 += v4  # v3.__iadd__(v4)가 호출됨
print(v3)  # Output: Vector(4, 6, 5)

v5 = Vector(1, 2, 3)
v5 += 10  # 모든 요소에 10을 더함
print(v5)  # Output: Vector(11, 12, 13)

 

Scalar 클래스와 Vector 클래스의 객체 간의 덧셈을 보여줍니다. s + v1에서는 Scalar 클래스의 __add__ 메서드가 호출되고, v1 + s에서는 Vector 클래스의 __add__ 메서드가 NotImplemented를 반환하여 Scalar 클래스의 __radd__ 메서드가 호출됩니다.

 

class Scalar:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        if isinstance(other, Vector):
            return Vector(other.x + self.value, other.y + self.value)
        return NotImplemented

    def __radd__(self, other):
        return self.__add__(other)

    def __repr__(self):
        return f"Scalar({self.value})"

# 사용 예시
s = Scalar(10)
v1 = Vector(1, 2)

# 스칼라와 벡터의 덧셈 (__radd__ 사용)
v6 = s + v1  # Scalar의 __add__가 호출됨
print(v6)    # Output: Vector(11, 12)

v7 = v1 + s  # Vector의 __add__가 호출되고 NotImplemented를 반환, Scalar의 __radd__가 호출됨
print(v7)    # Output: Vector(11, 12)

 

반응형

'Computer Science > python' 카테고리의 다른 글

동적 속성과 프로퍼티  (0) 2024.08.16
추상클래스의 활용  (0) 2024.06.12
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

Python의 추상 클래스와 MutableMapping을 활용한 데이터 구조 설계

Python은 객체 지향 프로그래밍(OOP) 언어로서, 추상 클래스를 통해 명확한 인터페이스를 정의하고 이를 기반으로 다양한 데이터 구조를 설계할 수 있는 기능을 제공합니다. 특히, Python의 collections.abc 모듈에서 제공하는 MutableMapping 추상 클래스를 활용하면, 딕셔너리와 같은 유연한 데이터 구조를 커스터마이즈하고 확장할 수 있습니다.

이 글에서는 Python의 추상 클래스 개념과 MutableMapping을 활용한 데이터 구조 설계 방법을 설명하고, 실질적인 예제를 통해 그 활용 방법을 소개합니다.

추상 클래스 (Abstract Class)

추상 클래스는 하나 이상의 추상 메서드를 포함하는 클래스입니다. 추상 메서드는 선언만 되어 있고, 실제 구현은 제공하지 않습니다. 추상 클래스는 객체를 직접 생성할 수 없으며, 반드시 상속받아 추상 메서드를 구현해야 합니다. 이를 통해 일관된 인터페이스를 강제할 수 있습니다.

추상 클래스의 정의

from abc import ABC, abstractmethod

class AbstractDataStructure(ABC):
    @abstractmethod
    def add(self, item):
        pass

    @abstractmethod
    def remove(self, item):
        pass

    @abstractmethod
    def find(self, item):
        pass

 

위 예제에서 AbstractDataStructure는 추상 클래스이며, add, remove, find 메서드는 추상 메서드로 정의되어 있습니다. 이 클래스는 상속받아 구체적인 구현을 제공해야 합니다.

MutableMapping 추상 클래스

collections.abc 모듈의 MutableMapping 추상 클래스는 딕셔너리와 같은 매핑 타입을 정의하는 데 사용됩니다. MutableMapping은 Mapping을 상속받아 변경 가능한 매핑 타입의 인터페이스를 정의합니다.

MutableMapping을 활용한 사용자 정의 클래스

MutableMapping을 상속받아 커스터마이즈된 딕셔너리 클래스를 구현할 수 있습니다. 이를 통해 기본 딕셔너리 기능을 확장하거나 새로운 기능을 추가할 수 있습니다.

from collections.abc import MutableMapping

class CustomDict(MutableMapping):
    def __init__(self):
        self._store = {}

    def __getitem__(self, key):
        return self._store[key]

    def __setitem__(self, key, value):
        self._store[key] = value

    def __delitem__(self, key):
        del self._store[key]

    def __iter__(self):
        return iter(self._store)

    def __len__(self):
        return len(self._store)

# CustomDict 사용 예제
custom_dict = CustomDict()
custom_dict['a'] = 1
custom_dict['b'] = 2

print(custom_dict['a'])  # 출력: 1
print(custom_dict)  # 출력: {'a': 1, 'b': 2}

del custom_dict['a']
print(custom_dict)  # 출력: {'b': 2}
print(len(custom_dict))  # 출력: 1

 

CustomDict에 예제 메서드 추가 및 활용

CustomDict 클래스에 예제 메서드를 추가하여 실제로 어떻게 활용할 수 있는지 살펴보겠습니다. 이 예제에서는 increment라는 메서드를 추가하여, 특정 키의 값을 증가시키는 기능을 구현해보겠습니다.

CustomDict 클래스 정의 및 예제 메서드 추가

 

from collections.abc import MutableMapping

class CustomDict(MutableMapping):
    def __init__(self):
        self._store = {}

    def __getitem__(self, key):
        return self._store[key]

    def __setitem__(self, key, value):
        self._store[key] = value

    def __delitem__(self, key):
        del self._store[key]

    def __iter__(self):
        return iter(self._store)

    def __len__(self):
        return len(self._store)

    # 예제 메서드 추가: 특정 키의 값을 증가시키는 메서드
    def increment(self, key, amount=1):
        if key in self._store:
            self._store[key] += amount
        else:
            self._store[key] = amount

# CustomDict 사용 예제
custom_dict = CustomDict()
custom_dict['a'] = 1
custom_dict.increment('a')
custom_dict.increment('b', 5)

print(custom_dict['a'])  # 출력: 2
print(custom_dict['b'])  # 출력: 5
print(custom_dict)  # 출력: {'a': 2, 'b': 5}

 

위 예제에서 CustomDict 클래스에 increment 메서드를 추가하여, 특정 키의 값을 증가시키는 기능을 구현했습니다.

Dictionary에서 비슷하게 구현

기본 dict를 사용하여 비슷한 기능을 구현할 수도 있습니다. 이를 위해 별도의 함수를 정의해보겠습니다.

# 기본 dict를 사용하여 increment 기능을 제공하는 함수
def increment(d, key, amount=1):
    if key in d:
        d[key] += amount
    else:
        d[key] = amount

# dict 사용 예제
basic_dict = {'a': 1}
increment(basic_dict, 'a')
increment(basic_dict, 'b', 5)

print(basic_dict['a'])  # 출력: 2
print(basic_dict['b'])  # 출력: 5
print(basic_dict)  # 출력: {'a': 2, 'b': 5}

CustomDict와 기본 dict를 사용한 구현의 장단점

CustomDict의 장점

  1. 메서드 추가 및 확장 용이:
    • 클래스 메서드로 기능을 구현하면, 객체 지향적인 접근이 가능하고, 상태를 쉽게 관리할 수 있습니다.
    • 메서드를 통해 기능을 캡슐화하여 코드의 재사용성과 유지보수성을 높일 수 있습니다.
  2. 인터페이스 일관성:
    • MutableMapping을 상속받아 딕셔너리와 동일한 인터페이스를 제공하므로, 기존의 딕셔너리 사용 패턴과 호환됩니다.
  3. 추가 기능 구현의 용이성:
    • CustomDict 클래스를 확장하여 새로운 기능을 쉽게 추가할 수 있습니다.

CustomDict의 단점

  1. 복잡성 증가:
    • 기본 dict를 사용하는 것보다 클래스를 정의하고 관리하는 데 더 많은 코드와 복잡성이 필요합니다.
  2. 성능 저하 가능성:
    • 추가된 추상화 계층으로 인해 성능이 약간 저하될 수 있습니다.

기본 dict의 장점

  1. 단순성:
    • 별도의 클래스를 정의하지 않고, 단순한 함수로 기능을 구현할 수 있어 코드가 간결합니다.
    • 기본 dict는 Python의 내장 자료형이므로 추가적인 학습이나 설정 없이 바로 사용할 수 있습니다.
  2. 성능:
    • Python의 기본 dict는 C로 구현되어 있어 매우 빠릅니다.

기본 dict의 단점

  1. 재사용성 및 유지보수성 저하:
    • 기능을 함수로 구현하면, 상태와 기능이 분리되어 있어 재사용성과 유지보수성이 낮아질 수 있습니다.
    • 여러 함수로 기능을 확장하는 경우, 코드의 일관성을 유지하기 어렵습니다.
  2. 객체 지향 프로그래밍의 한계:
    • 객체 지향 프로그래밍의 이점을 활용하지 못하므로, 복잡한 상태 관리나 기능 확장이 어렵습니다.

결론

  • CustomDict: 객체 지향적인 접근으로, 상태와 기능을 캡슐화하여 코드의 재사용성과 유지보수성을 높일 수 있습니다. 복잡한 기능을 확장하는 데 유리하지만, 기본 dict보다 구현과 관리가 더 복잡합니다.
  • 기본 dict: 간단하고 성능이 우수하지만, 복잡한 기능을 확장하거나 유지보수할 때 어려움이 있을 수 있습니다.

두 접근 방식 모두 장단점이 있으므로, 특정 상황과 요구 사항에 따라 적절한 방법을 선택하는 것이 중요합니다.

반응형

'Computer Science > python' 카테고리의 다른 글

동적 속성과 프로퍼티  (0) 2024.08.16
연산자 오버로딩  (0) 2024.07.09
프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
반응형

프로토콜 (Protocol)

프로토콜은 특정 메소드나 속성을 구현해야 하는 비공식적인 인터페이스입니다. Python은 강력한 덕 타이핑(duck typing) 덕분에 공식적으로 인터페이스를 정의하지 않아도 됩니다. 객체가 특정 메소드나 속성을 가지고 있다면, 그 객체는 해당 프로토콜을 구현한다고 간주합니다.

예를 들어, Python의 시퀀스 프로토콜은 __len__과 __getitem__ 메소드를 요구합니다. 리스트, 튜플, 문자열 등은 모두 이 프로토콜을 구현합니다.

 

 

인터페이스를 정의한다는 것은 클래스가 가져야 할 메소드와 속성을 명시하는 것을 의미합니다. 이는 객체 지향 프로그래밍에서 매우 중요한 개념입니다. 인터페이스는 클래스가 특정한 기능을 제공할 것이라는 계약(Contract)을 정의하며, 이를 통해 코드의 일관성을 유지하고 재사용성을 높일 수 있습니다.

인터페이스의 개념

인터페이스는 일반적으로 다음을 포함합니다:

  • 메소드 서명(Signature): 메소드의 이름, 매개변수, 반환 타입 등을 명시합니다.
  • 속성(Property): 클래스가 가져야 할 속성을 정의합니다.

인터페이스는 구현을 포함하지 않으며, 인터페이스를 상속받는 클래스는 해당 인터페이스에서 정의된 모든 메소드와 속성을 구현해야 합니다.

 

class CustomSequence:
    def __len__(self):
        return 10
    
    def __getitem__(self, index):
        return index * 2

seq = CustomSequence()
print(len(seq))        # 10
print(seq[3])          # 6

 

abc 모듈 (추상 기반 클래스)

Python의 abc 모듈은 추상 기반 클래스를 정의하는 기능을 제공합니다. 추상 클래스는 하나 이상의 추상 메소드를 포함할 수 있으며, 이러한 메소드는 서브클래스에서 반드시 구현해야 합니다. 이를 통해 공통 인터페이스를 정의하고 구현 강제를 할 수 있습니다.

추상 클래스 정의

추상 클래스는 ABC 클래스를 상속받고, 추상 메소드는 @abstractmethod 데코레이터를 사용하여 정의합니다.

 

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass

class Dog(Animal):
    def sound(self):
        return "Bark"

 

추상 클래스의 역할

  1. 공통 인터페이스 정의: 추상 클래스는 여러 구체적인 클래스가 반드시 구현해야 하는 메소드와 속성을 정의합니다. 이를 통해 모든 서브클래스가 동일한 인터페이스를 가지게 됩니다.
  2. 코드 재사용성 증가: 추상 클래스는 공통 기능을 한 곳에 모아서 구현할 수 있습니다. 이를 상속받는 구체적인 클래스들은 이러한 공통 기능을 재사용할 수 있습니다.
  3. 유지보수성 향상: 코드를 수정할 때, 공통 기능은 추상 클래스에서 한 번만 수정하면 되므로 유지보수성이 높아집니다.
  4. 다형성 지원: 동일한 인터페이스를 통해 다양한 클래스와 상호작용할 수 있게 하여 다형성을 지원합니다.

 

from abc import ABC, abstractmethod

class Animal(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def sound(self):
        return "Some generic animal sound"

    @abstractmethod
    def move(self):
        return "Some generic animal movement"

    def display_info(self):
        print(f"{self.name} says {self.sound()} and {self.move()}")

class Dog(Animal):
    def sound(self):
        return "Bark"

    def move(self):
        return "Runs"

class Cat(Animal):
    def sound(self):
        return "Meow"

    # move 메소드를 재정의하지 않음

class Fish(Animal):
    # sound 메소드를 재정의하지 않음

    def move(self):
        return "Swims"

# 동물원 관리 시스템
class Zoo:
    def __init__(self):
        self.animals = []

    def add_animal(self, animal: Animal):
        self.animals.append(animal)

    def show_all_animals(self):
        for animal in self.animals:
            animal.display_info()

# 동물원에 동물 추가
zoo = Zoo()
zoo.add_animal(Dog("Buddy"))
zoo.add_animal(Cat("Whiskers"))
zoo.add_animal(Fish("Nemo"))

# 모든 동물 정보 표시
zoo.show_all_animals()

 

실행 결과

Buddy says Bark and Runs
Whiskers says Meow and Some generic animal movement
Nemo says Some generic animal sound and Swims

 

예제에서는 추상클래스 "Animal"을 선언하고 각각 Dog, Cat 그리고 Fish 클래스가 이를 상속하도록 했습니다.

 

구체적인 클래스 Zoo 에서 Dog, Cat 그리고 Fish 오브젝트를 생성하였으며 여기서 모든 동물들에게 상속받은 추상 클래스 display_info를 호출하면 실행 결과를 출력하게 됩니다.

 

 

추상클래스는 다중 상속도 가능합니다.

from abc import ABC, abstractmethod

class Printable(ABC):
    @abstractmethod
    def print(self):
        pass

class Scannable(ABC):
    @abstractmethod
    def scan(self):
        pass

class MultifunctionPrinter(Printable, Scannable):
    def print(self):
        return "Printing document"

    def scan(self):
        return "Scanning document"

# MultifunctionPrinter 클래스는 Printable과 Scannable의 추상 메소드를 모두 구현해야 합니다
mfp = MultifunctionPrinter()
print(mfp.print())  # "Printing document"
print(mfp.scan())   # "Scanning document"

 

MultifunctionPrinter에 Printable와 Scannable 추상 클래스를 다중 상속 하고 있습니다.

 

일반 메서드의 경우, 서브클래스에서 재정의하지 않으면 상속된 메서드를 그대로 사용할 수 있습니다. 즉, 서브클래스는 필요에 따라 메서드를 재정의할 수도 있고, 그렇지 않으면 상위 클래스에서 정의된 메서드를 사용할 수 있습니다.

 

그러나 추상 클래스에서 정의된 추상 메서드는 특별한 경우입니다. 추상 메서드는 기본적으로 구현되지 않은 메서드입니다. 따라서 추상 클래스에서 추상 메서드를 정의하면, 이를 상속받는 클래스는 반드시 그 추상 메서드를 재정의하여 구현해야 합니다. 그렇지 않으면 해당 서브클래스는 추상 클래스로 간주되어 인스턴스화할 수 없습니다.

 

from abc import ABC, abstractmethod

class AbstractClass(ABC):
    @abstractmethod
    def abstract_method(self):
        pass

    def concrete_method(self):
        print("This is a concrete method from the abstract class.")

class ConcreteClass(AbstractClass):
    def abstract_method(self):
        print("This is the implementation of the abstract method.")

# 인스턴스 생성
instance = ConcreteClass()
instance.abstract_method()  # This is the implementation of the abstract method.
instance.concrete_method()  # This is a concrete method from the abstract class.

 

추상 클래스의 목적은 인터페이스를 정의하고, 특정 메서드를 서브클래스에서 반드시 구현하도록 강제하는 것입니다. 이를 통해 코드의 일관성을 유지하고, 서브클래스가 필요한 기능을 올바르게 구현하도록 보장합니다.

 

 

 

직접 ABC를 정의할 수 있지만 가능하면 collections.abc나 파이썬 표준 라이브러리의 모듈에서 상속해서 써라!

 

 

반응형

'Computer Science > python' 카테고리의 다른 글

연산자 오버로딩  (0) 2024.07.09
추상클래스의 활용  (0) 2024.06.12
Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
flask_sqlalchemy  (0) 2022.05.23
반응형

** 이 기능에 대해 '데코레이터'라는 명칭을 선택한 것에 대해 불만이 많았다. 그중 GoF 책에서 사용하는 용어와 일치하지 않는다는 불만이 가장 컸다. 데코레이터라는 명칭은 구문 트리를 파싱하고 애너테이션하는 컴파일러 분야에서의 용법과 관련이 더 깊다. _ PEP 318 - '함수 및 메서드 데코레이터'

 

특징  Python 데코레이터  GoF 데코레이터
주체 함수 또는 메서드 객체
목적 함수의 동작 변경/확장 객체의 동작 변경/확장
사용 방법 함수 위에 @데코레이터 사용 객체를 감싸는 데코레이터 객체 생성

 

 

Python 데코레이터는 하나의 함수(또는 메서드)를 다른 함수로 감싸서 추가 기능을 제공하는 도구입니다. 데코레이터는 함수의 동작을 수정하거나 확장할 때 유용합니다. 기본적인 형태는 다음과 같습니다:

  1. 기본적인 데코레이터 구조:
    • 데코레이터 함수는 다른 함수를 인자로 받아서 새로운 함수를 반환합니다.
  2. 사용법:
    • 데코레이터를 적용하려는 함수 위에 @데코레이터_이름을 붙입니다.
  3. 응용 사례:
    1. 로그 기록: 함수 호출과 결과를 기록하여 디버깅과 모니터링에 활용.
    2. 실행 시간 측정: 함수의 성능을 분석하고 최적화.
    3. 인증 및 권한 부여: 함수 호출 전에 인증 및 권한 확인.
    4. 캐싱: 함수의 결과를 캐시하여 성능 향상.

 

결국 데코레이터는 편리 구문(syntatic sugar)일 뿐이며 일반적인 콜러블과 동일하게 작동하지만 메타 프로그래밍을 할 때 편리합니다.

#1
@decorate
def target():
	print('running target()')
    
#2
def target():
	print('running target()')
target = decorate(target)

 

#1 와 #2는 본질적으로 같습니다.

 

하지만 #2의 방식은 아래 같은 단점이 있습니다.

  • 가독성 저하: 함수 정의와 데코레이터 적용이 분리되어 코드가 장황해짐.
  • 유지보수성 저하: 함수를 추가하거나 변경할 때 데코레이터 적용 부분도 수정해야 함.
  • 실수 가능성 증가: 데코레이터 적용을 잊어버릴 가능성이 있음.
  • 코드 중복 증가: 동일한 패턴의 반복으로 코드가 지저분해짐.
  • 코드 일관성 문제: 함수 정의와 데코레이터 적용 방식이 일관되지 않음.

 

예제) 1. 로그 기록 데코레이터

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Function {func.__name__} is called with arguments {args} and {kwargs}")
        result = func(*args, **kwargs)
        print(f"Function {func.__name__} returned {result}")
        return result
    return wrapper

@log_decorator
def add(a, b):
    return a + b

add(3, 5)
Function add is called with arguments (3, 5) and {}
Function add returned 8

 

예제) 2. 실행 시간 측정 데코레이터

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function {func.__name__} took {end_time - start_time} seconds to complete")
        return result
    return wrapper

@timer_decorator
def long_running_function():
    time.sleep(2)
    print("Function complete")

long_running_function()
Function complete
Function long_running_function took 2.0021233558654785 seconds to complete

 

 

데코레이터의 캐시 기능을 사용한 예제입니다.

import time

# 시간 차이를 계산하는 데코레이터 정의
def time_since_start(func):
    start_time = time.time()  # 데코레이터가 정의될 때 시작 시간을 기록

    def wrapper(*args, **kwargs):
        current_time = time.time()
        elapsed_time = current_time - start_time
        print(f"Time since start: {elapsed_time:.2f} seconds")
        return func(*args, **kwargs)
    
    return wrapper

# 데코레이터를 사용하여 함수 정의
@time_since_start
def example_function():
    print("Example function is called")

# 함수 호출
example_function()
time.sleep(2)
example_function()
time.sleep(3)
example_function()

 

출력 결과 

Time since start: 0.00 seconds
Example function is called
Time since start: 2.00 seconds
Example function is called
Time since start: 5.00 seconds
Example function is called

 

임포트 타임에서 time_since_start 함수가 호출될 때 start_time 변수가 선언되고 이후에 데코레이터에서는 wrapper 함수가 호출되면서 처음 선언된 start_time과의 시간 차이가 리턴 값으로 얻어집니다.

 

실제 사용 예제입니다.

 

django에서는 @login_required 라는 데코레이터로 api 요청이 왔을 때 사용자 인증을 거치고,login 상태가 아니면 login 페이지로 리다이렉트 하는 데코레이터를 사용합니다. 

login_required는 사전에 정의된 함수이며 코드는 아래와 같습니다.

# django/contrib/auth/decorators.py

from functools import wraps
from django.http import HttpResponseRedirect
from django.utils.decorators import available_attrs
from django.conf import settings

def user_passes_test(test_func, login_url=None, redirect_field_name='next'):
    """
    사용자 정의 테스트 함수를 통과하면 접근을 허용하는 데코레이터를 반환합니다.
    
    Args:
        test_func: 사용자 테스트 함수. 사용자 객체를 받아서 Boolean을 반환해야 합니다.
        login_url: 로그인 페이지 URL. 기본값은 settings.LOGIN_URL입니다.
        redirect_field_name: 리다이렉트 필드 이름. 기본값은 'next'입니다.
        
    Returns:
        view_func를 감싸는 데코레이터 함수.
    """
    if not login_url:
        login_url = settings.LOGIN_URL

    def decorator(view_func):
        @wraps(view_func, assigned=available_attrs(view_func))
        def _wrapped_view(request, *args, **kwargs):
            # 사용자 정의 테스트 함수로 사용자를 검사합니다.
            if test_func(request.user):
                return view_func(request, *args, **kwargs)
            # 테스트를 통과하지 못하면 로그인 페이지로 리다이렉트합니다.
            path = request.build_absolute_uri()
            from django.contrib.auth.views import redirect_to_login
            return redirect_to_login(path, login_url, redirect_field_name)
        return _wrapped_view
    return decorator

def login_required(function=None, redirect_field_name='next', login_url=None):
    """
    로그인된 사용자만 접근할 수 있도록 보호하는 데코레이터입니다.
    
    Args:
        function: 데코레이터가 적용될 함수. 생략할 수 있습니다.
        redirect_field_name: 로그인 후 리다이렉트할 때 사용할 GET 파라미터 이름. 기본값은 'next'입니다.
        login_url: 로그인 페이지 URL. 기본값은 settings.LOGIN_URL입니다.
        
    Returns:
        view_func를 감싸는 데코레이터 함수. function 인자가 주어지면 즉시 데코레이터를 반환합니다.
    """
    actual_decorator = user_passes_test(
        lambda u: u.is_authenticated,  # 사용자가 로그인되었는지 테스트합니다.
        login_url=login_url,
        redirect_field_name=redirect_field_name
    )
    if function:
        return actual_decorator(function)
    return actual_decorator

 

django에서 아래 같이 코드를 작성하면 my_view 함수를 실행하기 전 로그인 여부를 판단하고, 그에 따라 함수를 호출할지, 로그인 페이지로 이동할지 선택합니다.

# views.py
from django.contrib.auth.decorators import login_required
from django.http import HttpResponse

@login_required
def my_view(request):
    return HttpResponse("Hello, you are logged in!")

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('my_view/', views.my_view, name='my_view'),
]

 

 

데이터를 다룰때 사용하는 dataclass 데코레이터도 있습니다.

from dataclasses import dataclass, field

@dataclass
class Person:
    name: str
    age: int = 30
    hobbies: list = field(default_factory=list)

# 사용 예
p1 = Person(name="Alice")
p2 = Person(name="Bob", age=25)
p3 = Person(name="Charlie", hobbies=["reading", "swimming"])

print(p1)  # 출력: Person(name='Alice', age=30, hobbies=[])
print(p2)  # 출력: Person(name='Bob', age=25, hobbies=[])
print(p3)  # 출력: Person(name='Charlie', age=30, hobbies=['reading', 'swimming'])

 

dataclass는 클래스에 __init__(), __repr__(), __eq__() 메서드를 자동으로 추가합니다.

 

 
반응형

'Computer Science > python' 카테고리의 다른 글

추상클래스의 활용  (0) 2024.06.12
프로토콜과 'abc' 모듈  (0) 2024.06.11
seaborn clustermap color label  (0) 2022.05.24
flask_sqlalchemy  (0) 2022.05.23
python 설치  (0) 2022.04.06
반응형

seaborn 에서 clustermap에 color label 입히기.

condition_labels = df_data.condition
condition_uniq = sorted(condition_labels.unique())
condition_pal = sns.color_palette('husl',len(condition_uniq))
condition_lut = dict(zip(map(str, condition_uniq), condition_pal))
condition_colors = pd.Series(condition_labels).map(condition_lut)

tnm_labels = df_data.tnm
tnm_uniq = sorted(tnm_labels.unique())
tnm_pal = sns.color_palette('Paired',len(tnm_uniq))
tnm_lut = dict(zip(map(str, tnm_uniq), tnm_pal))
tnm_lut['NA']=(1,1,1)
tnm_colors = pd.Series(tnm_labels).map(tnm_lut)

age_labels = df_data.age
age_uniq = sorted(age_labels.unique())
age_pal = sns.color_palette('flare',len(age_uniq))
age_lut = dict(zip(map(str, sorted(age_labels.unique())), age_pal))
age_lut['NA']=(1,1,1)
age_colors = pd.Series(age_labels).map(age_lut)

condition_node_colors = pd.DataFrame(condition_colors).join(pd.DataFrame(tnm_colors)).join(pd.DataFrame(age_colors))
plt.figure(figsize=(100,120))
g = sns.clustermap(df_data.iloc[:,3:].T, cmap="vlag", col_colors = condition_node_colors)

for label in tnm_uniq:
    g.ax_col_dendrogram.bar(0, 0, color=tnm_lut[label], label=label, linewidth=10)
l2 = g.ax_col_dendrogram.legend(title='tnm', loc='center', ncol=2, bbox_to_anchor=(0.65, 1.05), bbox_transform=gcf().transFigure)
xx = []
for label in condition_uniq:
    x = g.ax_col_dendrogram.bar(0, 0, color=condition_lut[label], label=label, linewidth=10)
    xx.append(x)
#l1 = g.ax_col_dendrogram.legend(title='condition', loc='center', ncol=2, bbox_to_anchor=(0.2, 1.05), bbox_transform=gcf().transFigure)
legend3 = plt.legend(xx, condition_uniq, loc='center', title='condition', ncol=2, bbox_to_anchor=(0.35, 1.05), bbox_transform=gcf().transFigure)
yy = []
for label in age_uniq:
    y = g.ax_col_dendrogram.bar(0, 0, color=age_lut[label], label=label, linewidth=10)
    yy.append(y)
#l1 = g.ax_col_dendrogram.legend(title='condition', loc='center', ncol=2, bbox_to_anchor=(0.2, 1.05), bbox_transform=gcf().transFigure)
legend4 = plt.legend(yy, age_uniq, loc='center', title='age', ncol=5, bbox_to_anchor=(0.5, 1.15), bbox_transform=gcf().transFigure)

 

반응형

'Computer Science > python' 카테고리의 다른 글

프로토콜과 'abc' 모듈  (0) 2024.06.11
Python 데코레이터  (0) 2024.05.21
flask_sqlalchemy  (0) 2022.05.23
python 설치  (0) 2022.04.06
Progress bar 모듈 tqdm  (0) 2022.03.07
반응형

app.py

from database import db_session
from models import employees
from flask import Flask, Response, request
import pandas as pd
import json
import datetime

app = Flask(__name__)

@app.route('/employees/select', methods=['GET'])
def select():
        queryset = employees.query.limit(5)
        print(queryset)
        df = pd.read_sql(queryset.statement, queryset.session.bind)
        print(df)
        return Response(df.to_json(orient="records"), mimetype='application/json')

@app.route('/employees/insert', methods=['POST'])
def insert():
        emp_no = request.args.get('emp_no', default = 1, type = int)
        birth_date = request.args.get('birth_date', default = '9999-01-01')
        first_name = request.args.get('first_name', default='Gil-Dong', type=str)
        last_name = request.args.get('last_name', default='Hong', type=str)
        gender = request.args.get('gender', default='M')
        a = employees(emp_no, birth_date, first_name, last_name, gender)
        db_session.merge(a)
        db_session.commit()
        return 'done\n'

app.run(debug=True)

models.py

from sqlalchemy import Column, Integer, String, DateTime
from database import Base
import datetime

class employees(Base):
        __tablename__ = 'employees'
        emp_no = Column(Integer, primary_key=True)
        birth_date = Column(DateTime)
        first_name = Column(String)
        last_name = Column(String)
        gender = Column(String)
        hire_date = Column(DateTime)

        def __init__(self, emp_no, birth_date, first_name, last_name, gender):
                self.emp_no = emp_no
                self.birth_date = birth_date
                self.first_name = first_name
                self.last_name = last_name
                self.gender = gender
                self.hire_date =  datetime.date.today().strftime("%y-%m-%d")

        def __repr__(self):
                return f'{self.emp_no} : {self.first_name}'

database.py

from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine('mysql+mysqlconnector://root:0000@localhost/employees?charset=utf8', convert_unicode=True)
db_session = scoped_session(sessionmaker(autocommit=False,
                                         autoflush=False,
                                         bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()

def init_db():
    # import all modules here that might define models so that
    # they will be registered properly on the metadata.  Otherwise
    # you will have to import them first before calling init_db()
    import models
    Base.metadata.create_all(bind=engine)

 

반응형

'Computer Science > python' 카테고리의 다른 글

Python 데코레이터  (0) 2024.05.21
seaborn clustermap color label  (0) 2022.05.24
python 설치  (0) 2022.04.06
Progress bar 모듈 tqdm  (0) 2022.03.07
pandas 활용하기  (0) 2022.02.18
반응형

./configure --enable-loadable-sqlite-extensions

 

configure와 make까지 진행했을 때 설치를 더 진행해도 되지만 아래 메세지를 확인하고 설치가 안되는 모듈이 있음을 확인해야함.

 

Python build finished successfully!
The necessary bits to build these optional modules were not found:
_tkinter                                                       
To find the necessary bits, look in setup.py in detect_modules() for the module's name.

 

환경 변수를 설정했음에도 _sqlite3 가 지속적으로 보여서 확인해보니 setup.py 파일에서 직접 수정을 해야 했음.

 

sqlite_incdir = sqlite_libdir = None
sqlite_inc_paths = [ '/usr/include']
반응형

'Computer Science > python' 카테고리의 다른 글

seaborn clustermap color label  (0) 2022.05.24
flask_sqlalchemy  (0) 2022.05.23
Progress bar 모듈 tqdm  (0) 2022.03.07
pandas 활용하기  (0) 2022.02.18
logging 모듈 사용하기  (0) 2022.02.17
반응형

tqdm을 사용해서 얼마나 진행되었는지 작업 진행 정도를 표시함.

 

전체 양을 알 때와 모를 때를 나눠서 표시 할 수 있음.

 

전체 양을 모를 때 

from tqdm import tqdm
with open(filename) as f :
       for index, line in enumerate(tqdm(f, unit='reads', unit_scale=True, mininterval=1)):
               continue

결과물 :

58.9Mreads [00:24, 2.38Mreads/s]

3회 평균 소요 시간 21.7초

 

전체 양을 알 때

from tqdm import tqdm
with open(filename) as f :
        lines = f.readlines()
        for index, line in enumerate(tqdm(lines, total=len(lines), unit='reads', unit_scale=True, mininterval=1)):
                continue

결과물 :

100%|██████████████████████████████████████████████████████████| 58.9M/58.9M [00:15<00:00, 3.88Mreads/s]

3회 평균 소요 시간 30.6초 

 

f.readlines() 함수로 파일 전체를 읽어서 사이즈를 계산하고 진행 했을 때는 이미 메모리에 내용이 올라왔기 때문에 시간 당 읽는 줄 수는 빠르지만 파일을 읽는데 드는 시간으로 인해 총 시간은 더 느림 하지만 전체 진행율을 알 수 있다는 장점이 있음.

 

 

반응형

'Computer Science > python' 카테고리의 다른 글

flask_sqlalchemy  (0) 2022.05.23
python 설치  (0) 2022.04.06
pandas 활용하기  (0) 2022.02.18
logging 모듈 사용하기  (0) 2022.02.17
f-string을 활용한 regex 사용법  (0) 2022.02.15
반응형

 

import pandas as pd

df = pd.DataFrame()

#make dataframe from dictionary
tmp_df = pd.DataFrame([foo_dic], index=id)

#sum data by raw
total_count = tmp_df.sum(axis=1)[0]
tmp_df = tmp_df.div(total_count)

#concat multiple dataframe parellel
concat_df = pd.concat([df1,df2],axis=1).fillna(0)

#specific columns contain letter 'test'
df = df.loc[:,df.columns.str.contains('test', regex=True)]

#merge dataframe consider index
merge_df = pd.merge(df1, df2, left_index=True, right_index=True)
반응형

'Computer Science > python' 카테고리의 다른 글

python 설치  (0) 2022.04.06
Progress bar 모듈 tqdm  (0) 2022.03.07
logging 모듈 사용하기  (0) 2022.02.17
f-string을 활용한 regex 사용법  (0) 2022.02.15
Primer 서열 분석을 위한 python 코드  (0) 2021.08.17

+ Recent posts