<aside>
</aside>
์๋
ํ์ธ์! ์๋ฌด๋ฆฌ ๊ผผ๊ผผํ๊ฒ ์ฝ๋๋ฅผ ์ง๋, ํ๋ก๊ทธ๋จ์ ์์์น ๋ชปํ ๊ณณ์์ ์ค๋ฅ, ์ฆ **'์์ธ(Exception)'**๋ฅผ ์ผ์ผํค๊ณค ํฉ๋๋ค. ์ด๋ฐ ์์ธ ์ํฉ์ ์ ์ฒ๋ฆฌํ๊ณ ์์ธ์ ํ์
ํ๊ธฐ ์ํด ์ฐ๋ฆฌ๋ try...except ๊ตฌ๋ฌธ์ ์ฌ์ฉํด์์ฃ . ํ์ง๋ง ์์ธ๊ฐ ๋ฐ์ํ ์ ์๋ ๋ชจ๋ ๊ณณ์ ์ด ๊ตฌ๋ฌธ์ ๋ฃ๊ณ , ๋ ๊ทธ ์์์ ์ผ์ผ์ด ๋ก๊ทธ๋ฅผ ๋จ๊ธฐ๋ ๊ฒ์ ๊ฝค ๋ฒ๊ฑฐ๋ก์ด ์์
์
๋๋ค. ๐ฅ
์ด๋ฒ ์ฑํฐ์์๋ loguru๊ฐ ์ ๊ณตํ๋ ๊ฐ์ฅ ์ฐ์ํ ๊ธฐ๋ฅ ์ค ํ๋์ธ @logger.catch ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์๊ฐํฉ๋๋ค. ์ด '๋ง๋ฒ์ ๋งํ '๋ฅผ ํจ์์ ์์์ฃผ๊ธฐ๋ง ํ๋ฉด, ๊ท์ฐฎ์ try...except ์ฝ๋ ์์ด๋ ํจ์์์ ๋ฐ์ํ๋ ๋ชจ๋ ์์ธ๋ฅผ loguru๊ฐ ์๋์ผ๋ก ๊ฐ์งํ์ฌ ์์ฃผ ์์ธํ๊ณ ์น์ ํ ๋ก๊ทธ๋ฅผ ๋จ๊ฒจ์ค ๊ฑฐ์์!
์ด๋ฒ ์ฑํฐ๋ฅผ ๋ง์น๋ฉด ์ฌ๋ฌ๋ถ์ ๋ค์์ ํ ์ ์๊ฒ ๋ ๊ฑฐ์์!
try...except ๊ตฌ๋ฌธ์ ์ฌ์ฉํ ์์ธ ๋ก๊น
์ ๋ฒ๊ฑฐ๋ก์์ ์ดํดํฉ๋๋ค.@logger.catch ๋ฐ์ฝ๋ ์ดํฐ๋ฅผ ์ฌ์ฉํ์ฌ ๋จ ํ ์ค๋ก ํจ์์ ์์ธ๋ฅผ ์๋์ผ๋ก ๋ก๊น
ํ ์ ์์ต๋๋ค.@logger.catch๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง, ๊ทธ๋ฆฌ๊ณ ์ ๊ทธ๋ ๊ฒ ์์ธํ ๋ก๊ทธ๋ฅผ ๋จ๊ฒจ์ฃผ๋์ง ์ค๋ช
ํ ์ ์์ต๋๋ค.with logger.catch(): ๊ตฌ๋ฌธ์ ์ฌ์ฉํ์ฌ ํน์ ์ฝ๋ ๋ธ๋ก์ ์์ธ๋ง ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ์๊ฒ ๋ฉ๋๋ค.elegant_exceptions.py ํ์ผ์ ์๋ก ์ถ๊ฐํ์ฌ, ์ ํต์ ์ธ ๋ฐฉ์๊ณผ @logger.catch๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ ์ง์ ๋น๊ตํ๋ ์ค์ต์ ์งํํฉ๋๋ค.
ํ๋ก์ ํธ ๊ตฌ์กฐ
loguru-course/
โโโ venv/
โโโ ... (์ด์ ๊ฐ์ ํ์ผ๋ค)
โโโ elegant_exceptions.py <- ์๋ก ์ถ๊ฐ๋ ํ์ผ!
elegant_exceptions.py ์ ์ฒด ์ฝ๋
# elegant_exceptions.py
from loguru import logger
import sys
# ๋๋ฒ๊ทธ ๋ ๋ฒจ ์ด์์ ๋ก๊ทธ๋ฅผ ์ฝ์์์ ํ์ธํ ์ ์๋๋ก ์ค์
logger.remove()
logger.add(sys.stderr, level="DEBUG")
# --- ๋ฐฉ๋ฒ 1: ์ ํต์ ์ธ try...except ๊ตฌ๋ฌธ ---
def divide_traditionally(a, b):
logger.info(f"์ ํต ๋ฐฉ์ ์ฐ์ฐ: {a} / {b}")
try:
result = a / b
return result
except ZeroDivisionError as e:
# ์์ธ๊ฐ ๋ฐ์ํ๋ฉด, ์ง์ ์๋ฌ ๋ก๊ทธ๋ฅผ ๊ธฐ๋กํด์ผ ํฉ๋๋ค.
logger.error(f"์ ํต ๋ฐฉ์์์ ์ค๋ฅ ๋ฐ์! ์์ธ ์ ๋ณด: {e}")
# ์ฌ๊ธฐ์ ์์ธ๋ฅผ ๋ค์ ๋ฐ์์ํค์ง ์์ผ๋ฉด, ์ค๋ฅ๊ฐ ์กฐ์ฉํ ๋ฌด์๋ ์ ์์ต๋๋ค.
# raise
# --- ๋ฐฉ๋ฒ 2: @logger.catch ๋ฐ์ฝ๋ ์ดํฐ ์ฌ์ฉ ---
@logger.catch(reraise=True)
def divide_with_loguru(a, b):
logger.info(f"Loguru ๋ฐฉ์ ์ฐ์ฐ: {a} / {b}")
# try...except ๋ธ๋ก์ด ์ ํ ํ์ ์์ต๋๋ค!
result = a / b
return result
if __name__ == "__main__":
print("--- 1. ์ ํต์ ์ธ ์์ธ ์ฒ๋ฆฌ ํ
์คํธ ---")
divide_traditionally(10, 2)
divide_traditionally(10, 0) # ์ฐ๋ฆฌ๊ฐ ์ง์ ์์ฑํ ์๋ฌ ๋ก๊ทธ๋ง ์ถ๋ ฅ๋จ
print("\\n" + "="*50 + "\\n")
print("--- 2. @logger.catch ์์ธ ์ฒ๋ฆฌ ํ
์คํธ ---")
divide_with_loguru(10, 2)
try:
divide_with_loguru(10, 0) # loguru๊ฐ ์๋์ผ๋ก ์์ธํ ์๋ฌ ๋ก๊ทธ๋ฅผ ์ถ๋ ฅํจ
except ZeroDivisionError:
logger.success("ํ๋ก๊ทธ๋จ์ด ๋น์ ์ ์ข
๋ฃ๋์ง ์๊ณ ๋ค์์ผ๋ก ์งํ๋ฉ๋๋ค.")
try...exceptํ์ด์ฌ์์ ์์ธ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ์ try...except ๋ธ๋ก์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค. ์ฝ๋๋ฅผ ์คํ(try)ํด๋ณด๊ณ , ๋ง์ฝ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด(except) ์ฐ๋ฆฌ๊ฐ ์ ํด๋ ํ๋์ ํ๋ ๊ฒ์ด์ฃ .