Type in python#
C๋ฅผ ์ ์๋ ๊ฒ์ ์๋์ง๋ง C๋ฅผ ์์ํ๋ฉด ๋งจ ์ฒ์์ ๋ณ์๋ฅผ ์ ์ํ ๋ ๋ณ์์ ํ์ ์ ํจ๊ป ์ ์ํ๊ณค ํ๋ค. ์ด๋ฌํ ์ธ์ด๋ฅผ ์ ์ ์ธ ์ธ์ด๋ผ๊ณ ํ๋ค. ํ์ด์ฌ์ C์ ๋ค๋ฅด๊ฒ ๋์ ์ธ์ด๋ก ์๋ ค์ ธ ์์ผ๋ฉฐ ์ด๋ฌํ ์ธ์ด์ ํน์ง์ C์๋ ๋ฐ๋๋ก ํน์ ๋ณ์์ ํ์ ์ด ์ค๊ฐ์ ๋ฐ๋์ด๋ ๋๊ณ , ์ฒ์์ ๋ช ์ํ์ง ์์๋ ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค๋ ๊ฒ์ด๋ค. ํ์ง๋ง ๋ณ์์ Type์ ์ง์ ํ๊ณ ์ฌ์ฉํ๋ ๊ฒ์ ์๋ฌ ๊ด๋ฆฌ์ ์ฝ๋ ์ ์ง์ ์ค์ํ ์ญํ ์ ํ๋ค.
ํ์ Type?#
ํ๋ก๊ทธ๋๋ฐ์ ํ๋ฒ์ ์ ๋ฆฌํ ์ข์ ๋ฌธ์ฅ์ด ์๊ธธ๋ ๊ฐ์ ธ์ ๋ณด์๋ค.
ํ๋ก๊ทธ๋๋ฐ์ ๋ณ์๋ฅผ ํตํด ๊ฐ์ ์ ์ฅํ๊ณ ์ฐธ์กฐํ๋ฉฐ ์ฐ์ฐ์๋ก ๊ฐ์ ์ฐ์ฐ, ํ๊ฐํ๊ณ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ์ ์ํ ํ๋ฆ์ ์ด๋ก ๋ฐ์ดํฐ์ ํ๋ฆ์ ์ ์ดํ๊ณ ํจ์๋ก ์ฌ์ฌ์ฉ์ด ๊ฐ๋ฅํ ๊ตฌ๋ฌธ์ ์งํฉ์ ๋ง๋ค๋ฉฐ ๊ฐ์ฒด, ๋ฐฐ์ด ๋ฑ์ผ๋ก ์๋ฃ๋ฅผ ๊ตฌ์กฐํํ๋ ๊ฒ์ด๋ค.
โmodern javascript deep dive
๋ณ์(variable)์ ๊ฐ(value) = ๋ฐ์ดํฐ(data)
์ ๋ฉ๋ชจ๋ฆฌ ์์ ์์น,์ฃผ์(memory address)๋ฅผ ๊ธฐ์ตํ๋ ์ ์ฅ์์ด๋ค. ๊ทธ๋ฌ๋๊น ์ฐ๋ฆฌ๋ ๊ฐ์ ์ ์ฅํ๊ณ ๋ค์ ๋ถ๋ฌ์ฌ ๋ ์ปดํจํฐ์ฒ๋ผ ๋ชจ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๊ธฐ์ตํ ์ ์์ผ๋, ์ธ๊ฐ์ด ์ดํดํ๊ธฐ ์ฌ์ด identifier ์๋ณ์ = variable ๋ณ์
๋ก ๋ค๋ฝ๋ ๋ฝ ํ๋ ๊ฒ์ด๋ค. ๊ฐ์ฒด ์งํฅ ํ๋ก๊ทธ๋๋ฐ ํ ๋ ์ฒ์ ๋์ค๋ ๊ฒ์ด ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ผ๋ ๊ฒ์ ๋ฉ๋ชจ๋ฆฌ์์ ์๋ก ๋ค๋ฅธ ๊ณต๊ฐ(๋ค๋ฅธ ์ฃผ์)์ ์ ์ฅ๋์๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค๊ณ ํ๋ฉฐ โ== โ๋ก ์์ฑ๊ฐ์ ๊ฐ์์ง๋ผ๊ณ โisโ๋ก id๊ฐ ์ฃผ์๊ฐ์ ๋น๊ตํ๋ฉด ๋ค๋ฅผ ์ ์๋ค๊ณ ๋งํ๋ค. ์ฆ ๊ฐ์ ๊ฐ์๋ ์ฃผ์๋ ๋ค๋ฅด๋ฉด ๊ทธ๊ฒ์ ๋ณ์๊ฐ ๋ค๋ฅธ ๊ฒ์ด๊ณ , ๊ฐ์ฒด๋ก๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ก ๋ณผ ์ ์๋ค. ํ์ด์ฌ์์ ์ฃผ์๊ฐ์ ํ์ธํ๋ ค๋ฉด id(object)
ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
id(object)
Return the โidentityโ of an object. This is an integer which is guaranteed to be unique and constant for this object during its lifetime. Two objects with non-overlapping lifetimes may have the same id() value. CPython implementation detail: This is the address of the object in memory.
๋ฐ์ดํฐ ํ์
์ ๋ฌด์์ธ๊ฐ? ์ฝ๋ ์์ ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๊ณ ์ฐธ์กฐ๋ ์ ์์ด์ผ ํ๋ค. ๋ฉ๋ชจ๋ฆฌ์๋ 2์ง์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ์ ์ฅํ๊ธฐ ์ํ ๊ท์น์ด ์กด์ฌํ๊ณ , ๊ทธ ๊ธฐ๋ณธ์ ์ธ ์ฝ์๋ ํํ๊ฐ data type
์ด๋ค. ๊ธฐ๋ณธ์ ์ธ sty, int, boolean, none ๊ณผ ๊ฐ์ ํ์
์ ๋ํ ์ค๋ช
์ pass.
ํ์ด์ฌ์ 3.5v ์ด์๋ถํฐ Typing์ ์ง์ํ๊ณ ์๋ค. vscode๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ๊ธฐ๋ณธ์ ์ผ๋ก pylance๋ฅผ ์ฌ์ฉํ ๊ฒ์ด๊ณ , pyrigth์ ๊ธฐ๋ฅ์ pylance๊ฐ ์ด๋ฏธ ํ๊ณ ์๊ธฐ ๋๋ฌธ์ ๊ตณ์ด ๋ญ๊ฐ๋ฅผ ๊น ํ์๋ ์์ ๊ฒ์ด๋ค. ๊ธฐ๋ณธ์ ์ธ ์ฌ์ฉ ๋ฐฉ๋ฒ์ variable: type = default_value
์ด๋ฐ ์์ผ๋ก ์ฌ์ฉํ๋ค. arg_parser๋ฅผ ์ฌ์ฉํ ๋๋, class ๋ด๋ถ์ ๋ณ์๋ฅผ ๊ตฌ์กฐํ ํ ๋ ์ฌ์ฉํ๋ค. def์ return๊ฐ์ ์ง์ ํ ๋๋ -> type
์ ํ๋ฉด ๋๋ค.
a: int = 3
def temp_func(temp: str) -> str:
return temp.strip()
Tpye ์ข ๋ฅ#
Union -
Union[str,bytes,None]
์ฒ๋ผ ํ๋์ ํจ์์ ์ธ์์ ์ฌ๋ฌ ํ์ ์ด ์ฌ์ฉ๋ ์ ์์ ๋ ์ฌ์ฉํ๋ค. 3.10v ์ด์ ๋ถํฐ๋str | bytes | None
์ด๋ ๊ฒ๋ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.Optional - Union์ Optional๋ก ๋์ฒด๊ฐ๋ฅํ๋ค.
Optional[str]
๋ก ํ๋ฉด str or None์ ๋ฐ๋๋ค๋ ์๋ฏธ๋ค.List, Tuple, Dict - 3.9v ์ด์๋ถํฐ๋ typing์์ List,Tuple,Dict๋ฅผ importํ์ง ์์๋ ๊ฐ๋ฅํ๋ค.
Callable -
Callable[[arg1type,arg2type],returntype]
ํจ์๋ฅผ ์ธ์๋ก ๊ฐ์ง๋ ๊ฒฝ์ฐ. ๋ง์ฝ return ์ธ์๋ง ์ง์ ํ๊ณ ์ถ๋ค๋ฉดCallable[...,returntype]
๋ก ํ๋ฉด ๋๋ค.Type - class ๊ฐ์ฒด๋ ํด๋น ํ์ ์ ๊ทธ๋ฅ ๋ช ์ํ๋ฉด ๋๋ค. ํน์
Type[class_name]
์ง์ class ์ด๋ฆ์ ๋ฃ์ ์๋ ์๋ค.TypedDict - ๋์ ๋๋ฆฌ์ ๊ฒฝ์ฐ์๋ ๋ฐธ๋ฅ์ ํ์ ์ด ํ๋๋ก ๊ณ ์ ๋์ง๋ ์์ ์ ์๋ค. ์์๋ฐ๋ ํด๋์ค๋ฅผ ๋ง๋ ๋ค์ key-value type matching์ ์์ผ์ฃผ๋ฉด ๋๋ค. ํน์
dataclass
๋ก ๋์ฒดํด์ ์ฌ์ฉ๊ฐ๋ฅํ๋ค.Generator, Iterable, Iterator -
Generator[YieldType, SendType, ReturnType]
- sendtype์ input์ผ๋ก ๋ฐ๊ณ - yieldtype์ outputํ๋ฉฐ - returntype์ ์์ธ๊ฒฝ์ฐ์ ๋ฑ๋๋ค.Any - ์ฐ์ง๋ง๋ผ,
ParamSpec - ๊ฐ๋ณ ์์น ์ธ์(*args)์ ๊ฐ๋ณ ํค์๋ ์ธ์(**kwargs)๋ฅผ ๋ฐ๊ณ , ์ด๋ค์ ํ์ ์ ParamSpec์ผ๋ก ์ง์ ํฉ๋๋ค. ๋ํ, ๋ฐํ ํ์ ์ผ๋ก Tuple[ParamSpec, ParamSpec]์ ์ฌ์ฉํ์ฌ args์ kwargs์ ํ์ ์ ๋ํ๋ธ๋ค. 3.10v์ด์๋ถํฐ ๊ฐ๋ฅํ๋ค/
from typing import ParamSpec, Tuple
def my_function(*args: ParamSpec, **kwargs: ParamSpec) -> Tuple[ParamSpec, ParamSpec]:
return args, kwargs