Type 모듈

  • 다이나믹 타입의 특징으로 발생하는 단점을 해결하기 위해 사용
  • 가독성은 좋지만 실질적으로 강제성이 없어서 Mypy와 같은 정적 타입 검사를 해야함
  • (a: int) 형태로 type을 지정해주고 ->int 형태로 반환 타입을 정함
def add(a: int, b: int)->int:
    return a + b

print(add(10, 5))
print(add([1, 2], [3]))
print(add("hi ", "there"))

2. List, Dict, Tuple, Set

2.1 List

from typing import List


Vector = List[float]

def add(v: Vector, w: Vector)-> Vector:
    assert len(v) == len(w)
    return [v_i + w_i for v_i, w_i in zip(v, w)]

print(add([1, 2, 3], [4, 5, 6]))

2.2 Dict

from typing import Dict

countreis : Dict[str, str] = {"KR": "South Korea", "US": "United States"}

2.3 Tuple

from typing import Tuple

user: Tuple[int, str] = (3, "Tom")

2.4 Set

from typing import Set

chars: Set[str] = {"A", "B", "C"}

3. Callable

  • 함수에 대한 Type을 지정할 때 사용
from typing import Callable, List


def double_func(x):
    return x * 2


def make_double_list(func:Callable, args:List) -> List:
    result = []
    for i in args:
        result.append(func(i))

    return result


input_list = [1, 2, 3, 4, 5]
doubles = make_double_list(double_func, input_list)
print(doubles)

4. Union

  • 여러 개의 타입이 허용될 수 있는 상황에서 사용
from typing import Union


def toString(num: Union[int, float]) -> str:
    return str(num)

5. Optional

  • Optional[X]는 Union[X, None]과 동등함
def foo(arg: int = 0) -> None:
    ...

6. Iterable

  • 함수의 매개 변수에 대한 타입을 추상적으로 명시 할 수 있음
from typing import Iterable, List

def toStrings(nums: Iterable[int]) -> List[str]:
    return [str(x) for x in nums]

toString([1, 2, 3])
toStrings((1, 2, 3))
toStrings({1, 2, 3})

연습

ARABIC_TO_ROMAN = [
    (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"),
    (100, "C"), (90, "XC"), (50, "L"), (40, "XL"), (10, "X"),
    (9, "IX"), (5, "V"), (4, "IV"), (1, "I")
]

def convert_to_roman_numeral(number : int) -> str:
    result = list()
    # 1000, M / 900, CM  / .... / 100 C / 10 X
    for arabic, roman in ARABIC_TO_ROMAN:
        # 1, 230 / 0, 230 / .... / 2, 30 / 3, 0
        count, number = divmod(number, arabic)
        # M * 1 [M] / CM * 0 / ... / C*2 = CC [M, CC] / X*3 = XXX = [M, CC, XXX]
        result.append(roman * count)
    # MCCXXX
    return "".join(result)
#convert_to_roman_numeral(1230) = MCCXXX
print(convert_to_roman_numeral(1230))