예외처리

try:
    print("나누기")
    num1 = int(input('첫 번째 숫자를 입력 : '))
    num2 = int(input('두 번째 숫자를 입력 : '))
    print('{0} / {1} = {2}'.format(num1, num2, int(num1/num2)))
except ValueError:
    print('잘못된 값을 입력하였습니다')
except ZeroDivisionError as err: 
    print(err)
    
# 경우 1. try
# 나누기
# 첫 번째 숫자를 입력 : (10)
# 두 번째 숫자를 입력 : (3)
# 10 / 3 = 3

# 경우 2. except ValueError
# 첫 번째 숫자를 입력 : (10)
# 두 번째 숫자를 입력 : (three)
# 잘못된 값을 입력하였습니다

# 경우 3. except ZeroDivisionError
# 첫 번째 숫자를 입력 : (10)
# 두 번째 숫자를 입력 : (0)
# division by zero

try:
    print("나누기")
    nums = []
    nums.append(int(input('첫 번째 숫자를 입력 : ')))
    nums.append(int(input('두 번째 숫자를 입력 : ')))
    # num[2] 없다면? nums.append(int(nums[0] / nums[1]))
    print('{0} / {1} = {2}'.format(nums[0], nums[1], nums[2]))
except ValueError:
    print('잘못된 값을 입력하였습니다')
except ZeroDivisionError as err:
    print(err) # error 내용 출력
except Exception as err: # except Exception : 예외처리를 직접 작성한 것 외에 모든 에러를 처리
    print('알 수 없는 에러가 발생')
    print(err)

# 나누기
# 첫 번째 숫자를 입력 : (10)
# 두 번째 숫자를 입력 : (3)
# 알 수 없는 에러가 발생
# list index out of range

try:
    print('한 자리 숫자 나누기')
    num1 = int(input('첫 번째 숫자를 입력 : '))
    num2 = int(input('두 번째 숫자를 입력 : '))
    if num1 >= 10 or num2 >= 10:
        raise ValueError # 예외처리 발생
    print('{0} / {1} = {2}'.format(num1, num2, int(num1 / num2)))
except ValueError:
    print('잘못된 값을 입력하였습니다, 한 자리 숫자만 입력하세요')
    
# 한 자리 숫자 나누기
# 첫 번째 숫자를 입력 : (11)
# 두 번째 숫자를 입력 : (4)
# 잘못된 값을 입력하였습니다, 한 자리 숫자만 입력하세요


# 사용자 정의 예외처리
# class 개념 복습이 필요
class BigNumberError(Exception): # Exception이라는 class의 상속을 받는다
    def __init__(self, msg): # 변수 msg 사용
        self.msg = msg
        
    def __str__(self):
        return self.msg # __str__을 사용하여 변수 msg에 할당된 string을 반환
    
try:
    print('한 자리 숫자 나누기')
    num1 = int(input('첫 번째 숫자를 입력 : '))
    num2 = int(input('두 번째 숫자를 입력 : '))
    if num1 >= 10 or num2 >= 10:
        raise BigNumberError('입력값 : {0}, {1}'.format(num1, num2))
    print('{0} / {1} = {2}'.format(num1, num2, int(num1 / num2)))
except BigNumberError as err:
    print('잘못된 값을 입력하였습니다, 한 자리 숫자만 입력하세요')
    print(err)
finally:
    print('항상 실행') # error 발생 여부를 떠나 항상 실행되는 구문

# 한 자리 숫자 나누기
# 첫 번째 숫자를 입력 : (11)
# 두 번째 숫자를 입력 : (6)
# 잘못된 값을 입력하였습니다, 한 자리 숫자만 입력하세요
# 입력값 : 11, 6
# 항상 실행

Quiz 풀이

class SoldOutError(Exception):
    pass

try:
    chicken = 10
    waiting = 1
    while(True):
        print('[잔여 수량 : {0}]'.format(chicken))
        order = int(input('주문 수량 : '))
        if order < 0 | order is not int:
            raise ValueError
        elif order > chicken:
            print('재고 부족')
        else:
            print('[대기번호 {0}] {1}마리 주문 완료'.format(waiting, order))
            waiting += 1
            chicken -= order
            if chicken <= 0:
                raise SoldOutError
except ValueError:
    print('잘못된 값을 입력함')
except SoldOutError:
    print('재고가 소진되었습니다')
    
# [잔여 수량 : 10]
# 주문 수량 : (9)
# [대기번호 1] 9마리 주문 완료
# [잔여 수량 : 1]
# 주문 수량 : (2)
# 재고 부족
# [잔여 수량 : 1]
# 주문 수량 : (1)
# [대기번호 2] 1마리 주문 완료
# 재고가 소진되었습니다

Quiz 정답

class SoldOutError(Exception):
    pass

chicken = 10
waiting = 1
while(True):
    try:
        print('[잔여 수량 : {0}]'.format(chicken))
        order = int(input('주문 수량 : '))
        if order > chicken:
            print('재고 부족')
        elif order <= 0:
            raise ValueError
        else:
            print('[대기번호 {0}] {1}마리 주문 완료'.format(waiting, order))
            waiting += 1
            chicken -= order
            if chicken <= 0:
                raise SoldOutError
                    
    except ValueError:
        print('잘못된 값을 입력함')
    except SoldOutError:
        print('재고가 소진되었습니다')
        break

# [잔여 수량 : 10]
# 주문 수량 : (9)
# [대기번호 1] 9마리 주문 완료
# [잔여 수량 : 1]
# 주문 수량 : (2)
# 재고 부족
# [잔여 수량 : 1]
# 주문 수량 : (1)
# [대기번호 2] 1마리 주문 완료
# 재고가 소진되었습니다

Module

>> Module_test.py
# 일반 가격
def price(people):
    print('{0}명 가격은 {1}원'.format(people, people * 10000))
    
# 조조할인가
def price_morning(people):
    print('{0}명 조조 DC가격은 {1}원'.format(people, people * 6000))
    
# 군인할인가
def price_soldier(people):
    print('{0}명 군인 DC가격은 {1}원'.format(people, people * 4000))
<<

# import 'Module' as '~'
import Module_test as mt
mt.price(3)
mt.price_morning(4)
mt.price_soldier(5)
# 3명 가격은 30000원
# 4명 조조 DC가격은 24000원
# 5명 군인 DC가격은 20000원

# from 'Module' import *
from Module_test import *
price(3)
price_morning(4)
price_soldier(5)
# 3명 가격은 30000원
# 4명 조조 DC가격은 24000원
# 5명 군인 DC가격은 20000원

# from 'Module' import 'func1, func3, ...'
from Module_test import price, price_morning
price(3)
price_morning(4)
# 3명 가격은 30000원
# 4명 조조 DC가격은 24000원

# from 'Module' import 'func1' as '~'
from Module_test import price_soldier as pr
pr(5)
# 5명 군인 DC가격은 20000원

# import 'Pakage'.'Module'
import Pakage_test.aaamodule # import 'Pakage이름'.'Module이름(class or function은 바로 사용 불가)'
test = Pakage_test.aaamodule.aaaclass() # 'Pakage이름'.'Module이름'.'class이름' -> 변수에 저장
test.detail() # '변수'.'Method' -> 변수의 저장된 class의 method를 호출
# aaa pakage

# from 'Pakage'.'Module' import 'Class'
# object has no attribute error 발생 시 Kernel Shutdown 후 재실행 및 Module Overwritting, Regenerating
from Pakage_test.aaamodule import aaaclass # from 'Pakage이름'.'Module이름' import 'class이름'
test = aaaclass() # '변수' = 'class이름()'
test.aaamethod() # '변수'.'Method()'
# aaa pakage
from Pakage_test.bbbmodule import bbbclass
test = bbbclass()
test.bbbmethod()
# bbb pakage
from Pakage_test.cccmodule import cccclass
test = cccclass()
test.cccmethod()
# ccc pakage

>> __init__.ipynb
__all__ = ["aaamodule", "bbbmodule", "cccmodule"]
<<

# __all__
# from 'Pakage' import *
# 오류발생 빈번함 : name 'aaamodule' is not defined
from Pakage_test import * # Pakage의 공개 범위를 설정해야 한다. __init__ 파일에 "__all__ = ["aaamodule"]" 작성
test = aaamodule.aaaclass() # '변수' = 'Module이름'.'class이름()'
test.aaamethod() # '변수'.'Method이름'
# aaa pakage
test = bbbmodule.bbbclass()
test.bbbmethod()
# bbb pakage
test = cccmodule.cccclass()
test.cccmethod()
# ccc pakage

Module 동작 확인법 : 직접 실행 or 외부에서 실행

# Module이 잘 동작하는 지 확인, Module이 외부에서 가져와 쓰는 것인 지 알 수 있다
>> aaamodule.ipynb
class aaaclass:
    def aaamethod(self):
        print('aaa pakage')
        
if __name__ == "__main__":
    print('aaamodule을 직접 실행')
    print('이 문장은 Module을 직접 실행할 때만 표시')
    test = aaaclass()
    test.aaamethod()
else:
    print('aaamodule 외부에서 Module 호출') # 외부에서 Module을 호출할 시에 출력
    
# aaamodule을 직접 실행
# 이 문장은 Module을 직접 실행할 때만 표시
# aaa pakage

Pakage, Module 위치 확인

from Pakage_test import *
import inspect
print(inspect.getfile(aaamodule))
# /Users/chanuk/Python Projects/Boostcamp/Pakage_test/aaamodule.py
import random
print(inspect.getfile(random))
# /Users/chanuk/opt/anaconda3/lib/python3.9/random.py

Pakage Install

!pip install 'Pakage' # Pakage Install
!pip list # 설치되어 있는 Pakage들 표시
# Package                       Version
# ----------------------------- --------------------
# absl-py                       1.3.0
# aiohttp                       3.8.1
# .
# .
# .
# zipp                          3.7.0
# zope.interface                5.4.0

!pip show numpy # Pakage Info 표시
# Name: numpy
# Version: 1.21.5
# Summary: NumPy is the fundamental package for array
# computing with Python.
# Home-page: https://www.numpy.org
# Author: Travis E. Oliphant et al.
# Author-email: 
# License: BSD
# Location: /Users/chanuk/opt/anaconda3/lib/python3.9/site-packages

!pip install --upgrade numpy # 최신 버전으로 업데이트, 오류가 난다면 아마 비슷한 Pakage들의 충돌 현상

# 의존성 충돌로 인한 업데이트가 불가능할 시 다음 절차를 따른다
# 1. 의존성 충돌 Pakage 업데이트
!pip install --upgrade setuptools
!pip install --upgrade pip
# 2. 다른 패키지들도 업데이트
!pip install --upgrade --all-dependencies
# 3. numpy 업데이트
!pip install --upgrade numpy

내장 함수

# "list of python builtins"를 Web에 검색하면 내장 함수 정리된 내용을 볼 수 있다
# 내장 함수 : input, print, ...
# dir : 어떤 Object를 넘겨줬을 때 그 Object가 어떤 변수와 함수를 가지고 있는 지 표시
print(dir())
# ['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'quit']

import random
print(dir())
# ['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'quit', 'random']

import pickle
print(dir())
# ['In', 'Out', '_', '__', '___', '__builtin__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', '_dh', '_i', '_i1', '_ih', '_ii', '_iii', '_oh', 'exit', 'get_ipython', 'pickle', 'quit', 'random']

print(dir(random)) # random Module 내에서 쓸 수 있는 것들을 표시
# ['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_Sequence', '_Set', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', '_floor', '_inst', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 'paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', 'seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 'weibullvariate']

alist = [1, 2, 3]
print(dir(alist)) # alist에 대해서 사용할 수 있는 것들을 표시
# ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

name = 'aaa'
print(dir(name)) # name에 대해서 사용할 수 있는 것들을 표시
# ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

# map(function, iterable)
# function: A function that will be applied to each element of the iterable
# iterable을 처리할 함수를 입력
# iterable: An iterable (e.g., a list, tuple, or set) that contains the elements to be processed
# 함수로 처리할 요소들을 가진 a list, tuple, set, etc를 입력
def double(x):
    return x * 2
my_list = [1, 2, 3, 4, 5]
result = map(double, my_list)
print(result) # list로 형변환 필요
print(list(result))
# <map object at 0x7f9e81571130>
# [2, 4, 6, 8, 10]

# split function : 지정된 구분 기호를 기준으로 문자열을 분할 시에 사용
# string.split(separator, maxsplit)
# string : 분할할 문자열
# separator : 구분 기호(미입력은 띄어쓰기로 구분)
# maxsplit : Optional, 수행할 최대 분할 수를 지정하는 매개변수
string = "Hello, World!"
substring_list = string.split(",")
print(substring_list, type(substring_list))
# ['Hello', ' World!'] <class 'list'>

a, b = map(int, '111 222'.split())
print(a, b, type(a), type(b))
# 111 222 <class 'int'> <class 'int'>

a, b = (map(str, '333, 444'.split(', ')))
print(a, b, type(a), type(b))
# 333 444 <class 'str'> <class 'str'>

a, b = map(int, input('Input : ').split())
print(a, b, type(a), type(b))
# Input : (123 44444)
# 123 44444 <class 'int'> <class 'int'>

# Lambda Function
# 기존 함수 사용
def plus_one(x):
    return x + 1
print(plus_one(1)) # 작성한 함수를 호출하여 출력
# 2
def Plus(x):
	print(x + 1)
Plus(1)
# 2

# Lambda 함수 이용 : 이렇게는 사용 안함
plus_two = lambda x : x + 2 # x 값을 주면 x + 2를 반환, lambda 함수는 값을 변수에 할당해줘야한다
print(plus_two(1))
# 3

alist = [1, 2, 3]
print(list(map(plus_one, alist))) # 미리 정의해둔 함수를 alist에 적용 -> 함수 정의가 따로 작성되어야 한다
print(list(map(lambda x : x + 100, alist))) # Lambda 함수로 간단한 수식을 즉시 작성하여 alist에 적용시킴, 가장 많이 쓰는 형태
# [2, 3, 4]
# [101, 102, 103]

외장 함수

# "list of python modules"를 Web에 검색하면 외장 함수 정리된 내용을 볼 수 있다

# glob : 경로 내의 폴더/파일 목록 조회
import glob
print(glob.glob("*.py")) # 확장자가 py인 모든 파일
# ['Module_test.py'] # ipynb 제외 py로 끝나는 파일만 출력

# os : 운영체제에서 제공하는 기본 기능
import os
print(os.getcwd()) # 현재 디렉토리
# /Users/chanuk/Python Projects/Boostcamp


folder = 'sample_dir'
if os.path.exists(folder): # /Users/chanuk/Python Projects/Boostcamp (현재 디랙토리)에 'sample_dir'이라는 폴더가 있다면
    print('이미 존재하는 폴더')
    os.rmdir(folder) # 현재 디랙토리에 해당 폴더 삭제
    print(folder, '폴더를 삭제하였습니다')
    
else:
    os.makedirs(folder) # 현재 디랙토리에 해당 폴더 생성
    print(folder, '폴더를 생성하였습니다')
    
# 경우 1. 현재 디랙토리에 'sample_dir'이라는 폴더가 존재하지 않을 때
# sample_dir 폴더를 생성하였습니다

# 경우 2. 현재 디랙토리에 'sample_dir'이라는 폴더가 존재할 때
# 이미 존재하는 폴더
# sample_dir 폴더를 삭제하였습니다

import os
print(os.listdir()) # 현재 디랙토리에 존재하는 파일명 출력 : 리스트형
# ['Module_test.ipynb', 'Pakage_test', '__pycache__', 'pybasic2.ipynb', 'Module_test.py', 'pybasic4.ipynb', 'pybasic1.ipynb', '.ipynb_checkpoints', 'pybasic3.ipynb', 'pybasic5.ipynb']

import time
print(time.localtime())
print(time.strftime('%Y-%m-%d %H:%M:%S'))
# time.struct_time(tm_year=2023, tm_mon=4, tm_mday=22, tm_hour=21, tm_min=55, tm_sec=31, tm_wday=5, tm_yday=112, tm_isdst=0)
# 2023-04-22 21:55:31

import datetime
print(datetime.date.today())
# 2023-04-22

today = datetime.date.today() # 현재 : 2023-04-22
td = datetime.timedelta(days = 100) # 100일
print(today + td) # 현재로부터 100일 후의 날짜
# 2023-07-31

Quiz 풀이

>> chanuk.py
def sign():
    print('Solving Quiz')
<<    

import chanuk
chanuk.sign()
# Solving Quiz