🐢 파이썬 기초의 모든 것 🐢

[리스트] : ‘인덱스’를 기반으로 값을 저장

# IndexError 예외: 리스트의 길이를 넘는 인덱스로 요소에 접근하고자 할 때 발생

# ---------------------------------------- #

listA = [1,2,3]
listB = [4,5,6]

print(listA + listB) # [1,2,3,4,5,6]
print(listA * 3) # [1,2,3,1,2,3,1,2,3]
print(len(listA)) # 3

listA.extend(listB) # (연결 연산자 '+' 와 달리) '파괴적 처리'
print(listA) # [1,2,3,4,5,6]

# ---------------------------------------- #

listA = [1,2,3]
listB = [4,5,6]
listC = [4,5,6]

listA.append(4) # 리스트 뒤에 요소 추가
print(listA) # [1,2,3,4]

# 비교하기) 둘 다 '파괴적 처리'다.
# listB.append(listA) -> [4,5,6,[1,2,3]]
# listC += listA -> [4,5,6,1,2,3]

listA.insert(0,10) # 리스트 중간에 요소 추가
print(listA) # [10,1,2,3,4] 

# ---------------------------------------- #

#인덱스로 요소 제거

listA = [0,1,2,3,4,5]

del listA[1]
print(listA) # [0,2,3,4,5]

listA.pop()
print(listA) # [0,2,3,4]
listA.pop(2)
print(listA) # [0,2,4]

listB = [0,1,2,3,4,5,6]
listC = [0,1,2,3,4,5,6]
listD = [0,1,2,3,4,5,6]

del listB[3:6]
print(listB) # [0,1,2,6]
del listC[:3]
print(listC) # [3,4,5,6]
del listD[3:]
print(listD) # [0,1,2]

# ---------------------------------------- #

# <슬라이싱>
# 형식>> 리스트_이름 [ 시작_인덱스 : 끝_인덱스 : 단계 ]

numbers1 = [1,2,3,4,5,6,7,8]
numbers2 = [1,2,3,4,5,6,7,8]

print(numbers1[0:5:2]) # [1,3,5]
print(numbers2[::-1]) # [8,7,6,5,4,3,2,1]

# ---------------------------------------- #

# 값으로 제거

listA = [1,2,1,2]
listB = [0,1,2,3,4,5]

listA.remove(2)
print(listA) # [1,1,2]
# 리스트에 중복된 여러개의 값을 모두 제거하려면 반복문과 조합해서 사용해야함
# while 2 in listC:
#     listC.remove(2)
#     print(listC)

listB.clear()
print(listB) # []

# ---------------------------------------- #

# 요소 정렬하기

listA = [52, 273, 103, 32, 275, 1, 7]
listA.sort() # 오름차순
print(listA) # [1,7,32,52,103,273,275]
listA.sort(reverse = True) # 내림차순
print(listA) # [275,273,103,52,32,7,1]

# ---------------------------------------- #

# in / not in 연산자
# 특정 값이 내부에 있는지 확인

listA = [273,32,103,57,52]

print(273 in listA) # True
print(10 in listA) # False
print(273 not in listA) # False
print(10 not in listA) # True

# ---------------------------------------- #

# for와 리스트

array = [273,32,103,57,52]

for element in array:
	print(element)
# 출력 결과:
# 273
# 32
# 103
# 57
# 52

for character in "안녕하세요":
	print("-", character)
# 출력 결과:
# - 안
# - 녕
# - 하
# - 세
# - 요

listOfList = [
	[1,2,3],
	[4,5,6,7],
	[8,9]
]

for items in listOfList:
	for item in items:
		print(item)
# 출력 결과:
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

# ---------------------------------------- #

# 전개 연산자 '*'

listA = [1, 2, 3, 4]

listB = [*listA, *listA]
listC = [*listA, 5]
listD = [listA, listA]

print(listA) # [1, 2, 3, 4]
print(listB) # [1, 2, 3, 4, 1, 2, 3, 4]
print(listC) # [1, 2, 3, 4, 5]
print(listD) # [[1, 2, 3, 4], [1, 2, 3, 4]]


# ---------------------------------------- #

# min(리스트_이름): 리스트 내부의 최솟'값' 반환
# max(리스트_이름): 리스트 내부의 최댓'값' 반환

>>> max(iterable, *iterables, key=None, default=None)
>>> min(iterable, *iterables, key=None, default=None)

- iterable: 찾을 대상인 하나의 반복 가능한 객체 (필수)
- *iterables: 추가적인 iterable (선택)
- key: 함수를 인자로 받아 각 요소의 정렬 순서를 결정하는데 사용
- default: itrable이 비어있을 때 반환될 값 (비 지정시 ValueError 발생)

# sum(리스트_이름): 리스트 내부의 값을 모두 더한 '값'을 반환

# ---------------------------------------- #

# reversed(리스트_이름): 뒤집어진 '이터레이터'를 반환
# 반환 결과가 '리스트'가 아님을 기억하자!

numbers = [1,2,3,4,5]
for i in reversed(numbers):
	print('반복문: {}'.format(i))

# 실행 결과
# 반복문: 5
# 반복문: 4
# 반복문: 3
# 반복문: 2
# 반복문: 1

# ---------------------------------------- #

# enumerate(리스트_이름)
# : 리스트의 요소를 반복할 때 인덱스가 몇 번째인지 확인하기 위해 사용 

exampleList = ['A','B','C']

print('# 단순 출력')
print(exampleList)
print('-')

print('# enumerate()함수 적용')
print(enumerate(exampleList))
print('-')

print('# list() 함수로 강제 변환 출력')
print(list(enumerate(exampleList)))
print('-')

print('# 반복문과 조합하기')
for i, value in enumerate(exampleList): # for 와 in 사이에 변수가 두 개가 들어감
    print('{}번째 요소는 {}입니다.'.format(i,value))

# 출력 결과

# # 단순 출력
# ['A', 'B', 'C']
# -
# # enumerate()함수 적용
# <enumerate object at 0x000001E037044DC0>
# -
# # list() 함수로 강제 변환 출력
# [(0, 'A'), (1, 'B'), (2, 'C')]
# -
# # 반복문과 조합하기
# 0번째 요소는 A입니다.
# 1번째 요소는 B입니다.
# 2번째 요소는 C입니다.

[리스트 내포]

# 리스트_이름 = [ 표현식 for 반복자 in 반복할_수_있는_것 ]
# 리스트_이름 = [ 표현식 for 반복자 in 반복할_수_있는_것 if 조건문 ]

array1=[]
for i in range(0,20,2):
	array1.append(i * i)
print(array1)

# 대신

array2 = [i * i for i in range(0,20,2)]
# 해석: range(0,20,2)의 요소를 i라고 할 때 i * i로 리스트를 재조합해 줘
print(array2)

# ---------------------------------------- #

array = ['apple','plum','chocolate','banana','cherry']

# output = [fruit for fruit in array if fruit != 'chocolate'] 또는
output = [fruit 
	for fruit in array 
	if fruit != 'chocolate']

print(output) # ['apple', 'plum', 'banana', 'cherry']

[딕셔너리] : ‘키’를 기반으로 값을 저장

myDic = {
    "name" : "7D mango",
    "type" : "fruit",
    "ingredient" : ["mango", "sugar", "salt", "color"],
    "origin" : "Philippines"
}

print("name:",myDic["name"])
print("type:",myDic["type"])
print("ingredient:",myDic["ingredient"])
print(myDic["ingredient"][1])
print("origin:",myDic["origin"])
print()

# 출력 결과
# name: 7D mango
# type: fruit
# ingredient: ['mango', 'sugar', 'salt', 'color']
# sugar
# origin: Philippines

myDic["name"] = "8D mango" # 값을 수정
print("name:",myDic["name"]) # name: 8D mango

myDic["price"] = 5000 # 키와 값을 추가
print(myDic)

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines', 'price': 5000}

del myDic['type'] # 키와 값을 제거
print(myDic)

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines'}

# ---------------------------------------- #

myDic = {}
print('요소 추가 이전:',myDic)
myDic['name'] = 'new name'
myDic['head'] = 'new spirit'
myDic['body'] = 'new body'

print('요소 추가 이후:',myDic)

# 출력 결과
# 요소 추가 이전: {}
# 요소 추가 이후: {'name': 'new name', 'head': 'new spirit', 'body': 'new body'}

# ---------------------------------------- #

# KeyError : 존재하지 않는 키에 접근시 발생

# ---------------------------------------- #

myDic = {
    "name" : "7D mango",
    "type" : "fruit",
    "ingredient" : ["mango", "sugar", "salt", "color"],
    "origin" : "Philippines"
}

key = input('> 접근하고자 하는 키: ')

if key in myDic:
    print(myDic[key])
else:
    print("존재하지 않는 키에 접근하고 있습니다.")

# ---------------------------------------- #

# get() : '딕셔너리_이름 [ 키 ]' 와 같은 기능을 하는데
# 존재하지 않는 키에 접근할 경우 KeyError 발생 대신 None 출력

value = myDic.get('존재하지 않는 키')
print('값:',value)

if value == None:
    print("존재하지 않는 키에 접근했었습니다.")

# 출력 결과
# 값: None
# 존재하지 않는 키에 접근했었습니다.

# ---------------------------------------- #

# for문과 딕셔너리

for key in myDic:
    print(key,':',myDic[key])

# 출력 결과
# {'name': '8D mango', 'type': 'fruit',
# 'ingredient': ['mango', 'sugar', 'salt', 'color'],
# 'origin': 'Philippines'}

# ---------------------------------------- #

# 딕셔너리_이름.item() 활용

exDic = {
    'keyA':'valueA',
    'keyB':'valueB',
    'keyC':'valueC'
}

print(exDic.items())

# 출력 결과
# dict_items([('keyA', 'valueA'), ('keyB', 'valueB'), ('keyC', 'valueC')])

for key, element in exDic.items():
    print(key,':',element)

# 출력 결과
# keyA : valueA
# keyB : valueB
# keyC : valueC

💡 파이썬에서 범위를 지정할 때 범위의 끝으로 입력한 숫자는 포함되지 않는다! ex) range(0,10) ⇒ ‘0 부터 9 까지’ 를 의미함!!

[역반복문]

for i in range(4,-1,-1): # range(4,0-1,-1)  표현으로 강조할 수도 있음
    print("현재 반복 변수: {}".format(i))

for i in reversed(range(5)):
    print("현재 반복 변수: {}".format(i))

# 실행 결과
# 현재 반복 변수: 4
# 현재 반복 변수: 3
# 현재 반복 변수: 2
# 현재 반복 변수: 1
# 현재 반복 변수: 0

[중첩 반복문으로 별 쌓기]

output = ''

for i in range(1,11):
    for j in range(i):
        output+='*'
    output += '\n'

print(output)

# 출력결과
# *
# **
# ***
# ****
# *****
# ******
# *******
# ********
# *********
# **********

# ---------------------------------------- #

output = ''
for i in range(1,11):
    for j in range(11-i):
        output += ' '
    for k in range(2 * i - 1):
        output += '*'
    output += '\n'
print(output)

# 출력 결과
#           *
#          ***
#         *****
#        *******
#       *********
#      ***********
#     *************
#    ***************
#   *****************
#  *******************

[시간 기반 반복]

import time
number = 0

targetTick = time.time() + 5
while time.time() < targetTick:
    number += 1
print('5초 동안 {}번 반복했습니다.'.format(number))

# 출력 결과
# 5초 동안 29396701번 반복했습니다.

# ---------------------------------------- #

#10초 타이머 만들기

import time

count = 1
maxTime = time.time() + 10
while True:
    time.sleep(1)
    print(count)
    if time.time() > maxTime:
        break
    count += 1

[break / continue]

i = 1
while True:
    print('{}번째 반복문입니다.'.format(i))
    i += 1
    inputText = input('> 종료하시겠습니까?(y/n): ')
    if inputText in ['y','Y']:
        print('반복을 종료합니다')
        break

# 'y' 또는 'Y'가 입력될 때까지 반복
# 'y' 또는 'Y'가 입력되면 프로그램 종료

# ---------------------------------------- #

# 이중 루프 탈출

i = 1
while True:
    print('{}번째 반복문입니다.'.format(i))
    i += 1
    while True:
        inputText = input('종료하시겠습니까? (y/n) : ')
        if inputText in ['y','Y']:
            print('반복을 종료합니다.')
            break
        elif inputText in ['n', 'N']:
            break
        else:
            print('올바른 입력이 아닙니다!')
            continue
    if inputText in ['y', 'Y']:
        break

# ---------------------------------------- #

numbers = [5,15,6,20,7,25]

for number in numbers:
    if number < 10:
        continue
    print(number)

# 출력 결과
# 15
# 20
# 25

[여러 줄의 문자열 처리]

test = (
	'이렇게 입력해도 '
	'하나의 문자열로 연결되어 '
	'생성됩니다.'
)

print(test) # 이렇게 입력해도 하나의 문자열로 연결되어 생성됩니다.
print(type(test)) # <class 'str'>

# ---------------------------------------- #

# 문자열.join(문자열로_구성된_리스트)

print('::'.join(['1','2','3','4','5'])) # 1::2::3::4::5

# 응용:
number = int(input('정수 입력> '))

if number % 2 == 0:
    print('\n'.join([
        '입력한 문자열은 {}입니다.',
        '{}는(은) 짝수입니다.'
    ]).format(number, number))
else:
    print('\n'.join([
        '입력한 문자열은 {}입니다.',
        '{}는(은) 홀수입니다.'
    ]).format(number, number))
    
# 더 간단하게는

number = int(input('정수 입력>> '))

answer = [
        '입력한 문자열은{}입니다',
        '{}는(은) {}입니다.'
    ]
if number % 2 == 0:
    print('\n'.join(answer).format(number, number, 'even'))
else:
    print('\n'.join(answer).format(number, number, 'odd'))
    

[이터레이터]

# reversed() 함수와 이터레이터

numbers = [1,2,3,4,5,6]
rNum = reversed(numbers)

print(rNum)
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))
print(next(rNum))

# 실행 결과
# <list_reverseiterator object at 0x000001E037012D90>
# 6
# 5
# 4
# 3
# 2
# 1

💡 왜 reversed() 함수는 리스트를 바로 리턴해 주지 않고 이터레이터를 리턴해 주는 걸까? : 메모리의 효율성을 위해서! 수많은 요소가 들어있는 리스트를 복제한 뒤 뒤집어서 맅턴하는 것보다 기존에 있던 리스트를 활용해서 작업하는 것이 훨씬 효율적이기 때문.

---

[가변 매개변수 함수]

def printNtimes(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print('-') 
printNtimes(3, 'hello', 'world', 'good', 'morning')
print()
def printNtimes(n, *values):
    for i in range(n):
        for value in values:
            print(value)
        print('-') 
printNtimes(3, ['hello', 'world', 'good', 'morning'])
print()
def printNtimes(n, values):
    for i in range(n):
        for value in values:
            print(value)
        print('-')
        
printNtimes(3, ['hello', 'world', 'good', 'morning'])

# 출력 결과
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# 
# ['hello', 'world', 'good', 'morning']
# -
# ['hello', 'world', 'good', 'morning']
# -
# ['hello', 'world', 'good', 'morning']
# -
# 
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -
# hello
# world
# good
# morning
# -

[키워드 매개변수]

def printNtimes(*values, n = 2):
    for i in range(n):
        for value in values:
            print(value)
        print('-')
        
printNtimes('hello,','world!','good','morning!',n = 3)

# 출력 결과
# hello,
# world!
# good
# morning!
# -
# hello,
# world!
# good
# morning!
# -
# hello,
# world!
# good
# morning!
# -

# ---------------------------------------- #

def test(a,b = 10,c = 100):
    print(a + b + c)

# a는 일반 매개변수이므로 해당 위치에 반드시 입력해야함
# 기본 매개변수는 필요한 것만 키워드를 지정해서 입력해주는 편

test(10,20,30) 
test(a = 10,b = 100,c = 200)
test(c = 10,a = 100,b = 200)
test(10,c = 200)

# 출력 결과
# 60
# 310
# 310
# 220

# ---------------------------------------- #

def sumAll(start = 0,end = 100,step = 1):
    output = 0
    for i in range(start,end + 1,step):
        output += i
    return output

print('a.',sumAll(10,70,10))
print('b.',sumAll(end = 99))
print('c.',sumAll(end = 99,step = 2))

# 출력 결과
# a. 280
# b. 4950
# c. 2450

[리스트 평탄화]

def flatten(data):
    output = []
    for item in data:
        if type(item) == list:
            output += flatten(item)
        else:
            output.append(item)
    return output

example = [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
print('원본: {}'.format(example))
print('변환: {}'.format(flatten(example)))

# 출력 결과:
# 원본: [[1, 2, 3], [4, [5, 6]], 7, [8, 9]]
# 변환: [1, 2, 3, 4, 5, 6, 7, 8, 9]

• 함수의 변수는 함수 호출마다 따로따로 만들어진다.
• 함수가 끝나면 (리턴 되면) 함수를 호출했던 위치로 돌아옵니다.

[튜플]

# 괄호를 생략해도 튜플로 인식할 수 있는 경우는 괄호를 생략해도 된다.
tupleTest = 10, 20, 30, 40
print('tupleTest: {}'.format(tupleTest))
print('type(tupleTest): {}'.format(type(tupleTest)))

a, b, c = 10, 20, 30
print("a: {}, b: {}, c: {}".format(a, b, c))

# ---------------------------------------- #

****# 함수의 리턴에 튜플을 사용하면 여러 개의 값을 리턴하고 할당할 수 있다.
def test():
    return (10, 20)
a, b = test()

print('a: {}, b: {}'.format(a, b))****

# ---------------------------------------- #

# <튜플의 활용>

for i, value in enumerate(['a', 'b', 'c', 'd', 'e', 'f']):
    print('{}번째 요소는 {}입니다.'.format(i, value))

# 출력 결과:
# 0번째 요소는 a입니다.
# 1번째 요소는 b입니다.
# 2번째 요소는 c입니다.
# 3번째 요소는 d입니다.
# 4번째 요소는 e입니다.
# 5번째 요소는 f입니다.

# ---------------------------------------- #

# 몫과 나머지를 구하는 divmod() 함수: 튜플을 리턴

a, b = 97, 40
print(divmod(a, b))
x, y = divmod(a, b)
print('x: {}, y: {}'.format(x, y))

# 출력 결과
# (2, 17)
# x: 2, y: 17

[콜백 함수]

: 함수의 매개변수에 사용하는 함수

# 매개변수로 받은 함수를 10번 호출
def call_3_times(func):
    for i in range(3):
        func()
def printHello():
    print('Hello')
    
# 조합하기
call_3_times(printHello)

# 출력 결과:
# Hello
# Hello
# Hello

[람다]

# map(): 리스트의 요소를 함수에 넣고 리턴된 값으로 새로운 리스트를 구성
# filter(): 리스트의 요소를 함수에 넣고 리턴된 값이 True인 것으로, 새로운 리스트를 구성
# 형식: map(함수_명, 리스트_명) | filter(함수_명, 리스트_명)

def power(item):
    return item * item
def under3(item):
    return item < 3

# 대신

power = lambda x: x * x
under3 = lambda x: x < 3

# 람다 사용법 >> lambda 매개변수_명 : 리턴값

listInputA = [1,2,3,4,5]

outputA = map(power, listInputA)
print('map(power, listInputA):', outputA)
print('map(power, listInputA):', list(outputA))

outputB = filter(under3, listInputA)
print('filter(under3, listInputA):', outputB)
print('filter(under3, listInputA):', list(outputB))

# 출력 결과:
# map(power, listInputA): <map object at 0x000001D4560B7C70>
# map(power, listInputA): [1, 4, 9, 16, 25]
# filter(under3, listInputA): <filter object at 0x000001D456C4B7C0>
# filter(under3, listInputA): [1, 2]

# ---------------------------------------- #

# 인라인 람다
# 함수를 선언하지도 않고 매개변수로 바로 입력

outputA = map(lambda x: x * x, listInputA)
outputB = filter(lambda x: x < 3, listInputA)

[파일 입출력]

# <쓰기>

file = open('basic.txt', 'w')
file.write('Hi there!')
file.close()
# 또는
with open('basic.txt', 'w') as file:
    file.write('Hi there!')

# ---------------------------------------- #

# <읽기>

file = open('basic.txt', 'r')
contents = file.read()
print(contents)
# 또는
with open('basic.txt', 'r') as file:
    contents = file.read()
print(contents)

# ---------------------------------------- #

import random as rand

hanguls = list('가나다라마바사아자차카타파하')

with open('info.txt', 'w') as file:
    for i in range(1000):
        name = rand.choice(hanguls) + rand.choice(hanguls)
        weight = rand.randrange(40, 100)
        height = rand.randrange(140, 200)
        
        file.write('{}, {}, {}\n'.format(name, weight, height))

with open('info.txt', 'r') as file:
    for line in file:
        (name, weight, height) = line.strip().split(',')
        
        # 데이터가 문제가 없는지 확인합니다: 문제가 있으면 지나감
        if (not name) or (not weight) or (not height):
            continue
        
        bmi= int(weight) / (int(weight) / 100) ** 2
        result = ''
        if 25 <= bmi:
            result = '과체중'
        elif 18.5 <= bmi:
            result = '정상 체중'
        else:
            result = '저체중'
        
        print('\n'.join([
            '이름: {}', 
            '몸무게: {}',
            '키: {}',
            'BMI: {:.2f}',
            '결과: {}'
        ]).format(name, weight, height, bmi, result))

# N줄만 출력하려면: count를 하나씩 늘려가서 N만큼 출력되면 break 되도록 수정하면 됨!

[제너레이터]

: 함수의 코드를 조금씩 실행할 때 사용. 메모리 효율성을 위해서. 제너레이터와 이터레이터는 완전히 같지는 않지만 기본적인 단계에서는 거의 비슷하다고 봐도 무방함.

def test():
    print('A 지점 통과')
    yield 1
    print('B 지점 통과')
    yield 2
    print('C 지점 통과')

output = test()

print('D 지점 통과')
a = next(output)
print(a)

print('E 지점 통과')
b = next(output)
print(b)

print('F 지점 통과')
c = next(output)
print(c)

next(output)

# 실행 결과:
# D 지점 통과
# A 지점 통과
# 1
# E 지점 통과
# B 지점 통과
# 2
# F 지점 통과
# C 지점 통과
# ---------------------------------------------------------------------------
# StopIteration                             Traceback (most recent call last)
# ~\AppData\Local\Temp\ipykernel_21056\1173299310.py in <module>
#      17 
#      18 print('F 지점 통과')
# ---> 19 c = next(output)
#      20 print(c)
#      21 
# 
# StopIteration:

[global]

global a
a = 10

def func():
    global a 
    print(a) # 함수 내부에서 함수 외부에 있는 변수를 출력
    a = 20 # 함수 외부에 있는 번수의 값을 교체
    
func()
print(a)

# 실행 결과:
# 10
# 20

# global 키워드를 사용하지 않으면 'UnboundLocalError'를 발생시킴

[예외 처리]

• 예외 / 런타임 오류: 프로그램 실행 중에 발생하는 오류
• 방법
  • 조건문 사용
  • try 구문 사용

- 조건문 사용

userInputA = input('정수 입력')

if userInputA.isdigit(): # 0이상의 정수를 입력받았을 때만 작동
    numberInputA = int(userInputA)
	    
    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
else:
    print('정수를 입력하지 않았습니다.')

# ---------------------------------------- #

- try except 구문

try:
    numberInputA = int(input('정수 입력>>'))
    
    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
except:
    print('무언가 잘못되었습니다')

# ---------------------------------------- #

- try except else finally 구문

- 형식:
			try:
				예외가 발생할 가능성이 있는 코드
			except:
				예외가 발생했을 때 실행할 코드
			else:
				예외가 발생하지 않았을 때 실행할 코드
			finally:
				무조건 실행할 코드

try:
  numberInputA = int(input('정수 입력>>'))

		print('원의 반지름>>', numberInputA)
	  print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
	  print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
except:
		print('정수를 입력하지 않았습니다!')
else:
	  print('예외가 발생하지 않았습니다.')
finally:
		print('일단 프로그램이 어떻게든 끝났습니다.')

# 규칙:
# 1. try 구문은 단독으로 사용할 수 없으며, 반드시 except 구문 또는 finally 구문과 함께 사용
# 2. else 구문은 반드시 except 구문 뒤에 사용
# (즉, try else 구문은 불가능)

# finally 키워드는 굳이 없어도 되지만 코드 정리를 위해 사용한다
# try 구문 내부에서 return 키워드로 중간에서 탈출해도 finally 구문은 반드시 실행

def test():
    print('1st line of test()')
    try:
        print('try')
        return
        print('next to try')
    except:
        print('except')
    else:
        print('else')
    finally:
        print('finally')
    print('end line of test()')
    
test()

# 실행 결과:
# 1st line of test()
# try
# finally

[예외 고급]

#예외 객체

try:
    numberInputA = int(input('정수 입력>>'))
    
    print('원의 반지름>>', numberInputA)
    print('원의 둘레>> {:.2f}'.format(2 * 3.14 * numberInputA))
    print('원의 넓이>> {:.2f}'.format(3.14 * numberInputA * numberInputA))
    
except Exception as exception:
    print('type(exception):', type(exception))
    print('exception:', exception)

# 실행 결과:
# 정수 입력>> yes
# type(exception): <class 'ValueError'>
# exception: invalid literal for int() with base 10: 'yes'

# ---------------------------------------- #

# 예외 구분하기

listNumber = [52, 273, 32, 72, 100]

try:
    numberInput = int(input('정수 입력>>'))
    print('{}번째 요소: {}'.format(numberInput, listNumber[numberInput]))
except ValueError:
    print('정수를 입력해주세요!')
except IndexError:
    print('리스트의 인덱스를 벗어남.')

# ---------------------------------------- #

# 모든 예외 잡기

listNumber = [52, 273, 32, 72, 100]

try:
    numberInput = int(input('정수 입력>>'))
    print('{}번째 요소: {}'.format(numberInput, listNumber[numberInput]))
    예외.발생해주세요()

except ValueError as exception:
    print('정수를 입력해주세요!')
    print(type(exception), excpetion)
except IndexError as exception:
    print('리스트의 인덱스를 벗어남.')
    print(type(exception), excpetion)
except Exception as exception:
    print('미리 파악하지 못한 예외가 발생했습니다.')
    print(type(exception), exception)