TUTOR 리덕토의 배움세상

먼길 오느라 수고들 많으셨습니다. 이번 포스팅은 Python과 매우 친해지기 그 마지막 시간인 Decorator이다. 물론 여기까지로 Python의 100%를 안다고 생각하면 큰 오산이다. 다음 시간부터는 모듈 알아보기 포스팅을 올릴 예정이니, 계속해서 Python에 대한 애정을 멈추지 말아주었으면 한다.

Decorator

여러분이 만들고 있는 함수의 프로그램 동작시간을 측정한다고 가정을 하자. 간단하게 import datetime모듈의 현재시간을 출력하는 datetime.datetime.now() 함수를 이용해보자. 

## 코드 : 
import datetime

def add(val1, val2) :
    print(datetime.datetime.now())
    print(val1+val2)
    print(datetime.datetime.now())
    return val1+val2

def sub(val1, val2) :
    print(datetime.datetime.now())
	print(val1-val2)
    print(datetime.datetime.now())
    return val1-val2

def div(val1, val2) :
    print(datetime.datetime.now())
    print(val1/val2)
    print(datetime.datetime.now())
    return val1/val2

if __name__=="__main__" :
    print(add(3,5))
    print("\n")
    print(sub(3,5))
    print("\n")
    print(div(3,5))
    
## 출력 :

2021-04-10 21:40:10.219000
8
2021-04-10 21:40:10.271000
8


2021-04-10 21:40:10.309000
-2
2021-04-10 21:40:10.337000
-2


2021-04-10 21:40:10.373000
0
2021-04-10 21:40:10.400000
0

으흠; 모든 함수에 대해서 datetime.datetime.now()를 2번씩 처주는 동일한 일을 해줄 필요가 있을까? Decorator는 이러한 문제의 해결책이다. 다음의 예시를 보자

import datetime

def deco(func) :
    def decorated() :
        print(datetime.datetime.now())
        func()
        print(datetime.datetime.now())
    return decorated
    
@deco
def function() :
    print("Function start")

if __name__=="__main__" :
    function()

우선 함수 그 자체를 파라미터로 받아들이는 또다른 함수 deco를 정의하였다. deco의 내부에는 인라인 함수, decorated를 정의하여 func() 실행 앞뒤로 우리가 원하는 행위인 print(datetime.datetime.now())를 실행해주었고, deco함수는 decorated 함수를 리턴하는 것으로 정의부는 마무리된다. 

decorated 받을 함수인 functiond은 앞부분에 @deco를 기술하여 이 함수가 deco함수로 decorated 될 것을 명시해 주었다.

* Decorator에서 인자를 사용하려면, @deco("some")으로 사용하면된다. 

자 이렇게 Python과 매우 친해지기 포스팅이 마무리되었다. 필자도 수고했고, 여러분도 수고 많았다. 처음에 Python을 그림에 비유했는데, 이는 아직도 유효하다. 여러분들은 그림의 기초적인 테크닉을 배운 것이고, 이제 여러 가지 프로그램을 만들 때 이 정보들이 여러분에게 큰 도움이 될 것이라고 확신한다. 

lambda는 간단하게 함수를 생성할 수 있게 도와주는 예약어이다. 이렇게 생성된 함수를 람다 함수 또는 익명함수라고도 부른다. 람다로 생성을 한 함수들은 여러 가지 내장 함수들로 조금 더 정밀한 코드를 작성할 수 있는데, 자세한 것은 아래 사용 코드를 보고 이야기하자

Lambda의 정의와 사용

람다함수는 다음과 같이 생성, 사용한다. 

>>> my_foo = lambda x : x+3
>>> my_foo(3)
6
>>> my_foo(5)
8

일반 함수처럼 정의했다면 다음과 같은 코드였을 것이다.

def my_foo(value) :
    return value+3

물론 여러개의 인자를 받을 수도 있다.

>>> my_foo = lambda x,y,z : x*y*z
>>> my_foo(1,2,3)
6

사용법이 어렵게 느껴지지 않기를 바란다. (그래야 아래가 쉽다)

map()

map은 함수와, iterable 한 객체를 인자로 받아들인다. 아래의 코드를 예시로 보자

>>> my_list = list(map(lambda x : x+3, range(5))
>>> my_list
[3, 4, 5, 6, 7]

* range 객체는 iterable한 객체로, 낮은 용량으로 list를 구현할 수 있게 해 준다. 완전한 list는 아니고, range라는 객체로 생성된다.

filter()

filter또한 함수와, iterable 한 객체를 인자로 받아들이는데, 함수의 결과가 True인 것만을 원소로 추가한다. 아래의 코드를 예시로 보자

>>> my_list = list(filter(lambda x: x%2==0, range(10)))
>>> my_list
[0, 2, 4, 6, 8]

사실 람다와 친구인 reduce라는 함수도 있다. functools의 하위 함수인데, 모듈을 추가하여 설명하는 건 되도록 나중으로 미루고 싶어서 설명을 거두었다. 다음 시간은 Python과 친해지기 그 마지막 편인 Decorator를 만나보도록 하자

이제 매우 친해지기의 강의도 얼마 남지 않았다.(아마 decorator와 lambda까지 하면 여러분이 Python과 충분히 친해진 것을 느낄 것이다.) 이번 시간에는 Python이 제공하는 깔끔하고 멋있는 기능인 내포에 대해서 알아보자

LIST Comprehension

일단 내포가 무엇인지를 알아야한다. 내포는 자료구조 안에 for와 if 등을 활용하여 코드를 직관적이고 단순하게 하고, 실행 속도의 향상도 도모하는 All stat 아이템 같은 존재이다.

다음 코드는 0부터 9까지 짝수만을 선택하여 my_list로 만드는 코드이다.

>>> my_list = [x for x in range(10) if x%2==0]
>>> my_list
[0, 2, 4, 6, 8]

다음과 같이 for를 중첩하여 생성할 수도 있다.

>>> my_list = [x*y for x in range(5) for y in range(5)]
>>> my_list
[0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 2, 4, 6, 8, 0, 3, 6, 9, 12, 0, 4, 8, 12, 16]

작살난다.

자주쓰는 예시로 다음과 같이 현재 폴더의. txt확장자만을 가져오는 경우 다음과 같은 내포를 사용할 수 있다.

>>> import os
>>> cur_txt = [x for x in os.listdir() if x.endswith(".txt")]

Dict Comprehension

Dictionary또한 Python 3 버전 이상은 내포를 지원하게 되었다. 다음은 0~9까지의 수를 key로 가지고, 그 세제 곱수를 value로 가지는 my_dict의 내포 선언이다.

>>> my_dict = {x:x**3 for x in range(10)}
>>> my_dict
{0: 0, 1: 1, 2: 8, 3: 27, 4: 64, 5: 125, 6: 216, 7: 343, 8: 512, 9: 729}

물론 dictionary의 내포도 중첩된 for문을 활용할 수 있지만, dictionary의 특성상 중첩된 key를 가질 수 없기 때문에 다음과 같이 사용하면 key인 x 당 마지막 루프의 y만이 적용된다.(물론 x, y를 이용해서 유일한 key를 만들면 해결되는 문제이다.

>>> my_dict = {x:x*y for x in range(10) for y in range(5)}
>>> my_dict
{0: 0, 1: 4, 2: 8, 3: 12, 4: 16, 5: 20, 6: 24, 7: 28, 8: 32, 9: 36}

이외에도 SET자료형도 비슷한 방식으로 내포 선언할 수 있으니, SET자료형을 선언할 기회가 생긴다면 써보도록 하자(아마 잘 안 올 것이다.

내포는 다른 프로그램 언어는 대부분 지원하지 않는 기능이다. 아마 다른 코드를 주로 사용하다가 이 내포 기능을 Python에서 처음 만난 사람이라면 Python에 매력에 더욱 반할 것이다. 다음 시간에는 익명 함수 Lambda에 대해서 알아보도록 하자

예약어 시간 for문의 정의를 본 사람은 Iterable이라는 말을 보았을 것이다.(안 썼나?) 이번 시간에는 Iterator에 대해서 알아보면서 우리가 사용하는 반복문을 조금 더 높은 수준으로 올려보자

Iterable 한 것과 Iterator

Iterable 하다는 것은 문자 그대로 반복이 가능하다는 의미를 가진다. 즉 다음과 같은 객체들은 for, enumerate에서 반복할 수 있다.

Iterable 한 객체 : list, dict, set, tuple, range, str 등등

Iterable 한 객체들은 내부적으로 __iter__() 매소드를 가지고 있다. 이를 이용하여 아래와 같은 Iterator 객체를 생성할 수 있다.

>> my_list = [1,2,3,4,5,6,7,8,9,10]
>> my_iter = iter(my_list)

또한 Iterator로 생성된 객체는 next매소드를 가지고 있어, next를 이용하여 원소들을 탐색할 수 있다.

>>> my_list = [1,2,3,4,5,6,7,8,9,10]
>>> my_iter = iter(my_list)
>>> next(my_iter)
1
>>> next(my_iter)
2
>>> next(my_iter)
3
>>> next(my_iter)
4

## my_iter의 끝으로 가면 next호출 시 Exception이 발생한다.

Advanced For

향상된 for문은 다른 프로그래밍언어에서도 심심치 않게 볼 수 있는 것으로 Iterable 한 객체들의 원소를 반복자가 순회하는 것이다. 다음의 예시를 보자

## 코드 :
fruits = ["apple","orange","strawberry","kiwi"]

for i in fruits :
    print(i)

## 출력 :
apple
orange
strawberry
kiwi

한 가지 재미있는 점은 반복자가 인덱스였을 때(range()를 이용한 순회)는 원소의 수정이 가능했지만, A-for문을 통한 반복에서는 원소의 직접 수정이 안된다는 점이다.

## 코드 :
fruits = ["apple","orange","strawberry","kiwi"]

for i in fruits :
    i="ruin"

print(fruits)

for i in range(len(fruits)) :
    fruits[i] = "ruin"

print(fruits)

## 출력 :
['apple', 'orange', 'strawberry', 'kiwi']
['ruin', 'ruin', 'ruin', 'ruin']

Generator

이러한 Iterator는 지정된 자료구조말고도 Generator를 이용하여 사용자가 정의할 수 있다. 다음의 예시를 보자 

## 코드 : 
def my_iterator() :
    my_list = [1,2,3,4,5,6,7,8,9,10]
    for i in range(len(my_list)) :
        yield my_list[i]

a = my_iterator()
next(a)
next(a)
next(a)

## 출력 :
1
2
3

이렇게 생성된 generator는 A-for문에 사용할 수 있다.

## 코드 : 
def my_iterator() :
    my_list = [1,2,3,4,5,6,7,8,9,10]
    for i in range(len(my_list)) :
        yield my_list[i]

a = my_iterator()

for i in a :
    print(i)


## 출력 :
1
2
3
4
5
6
7
8
9
10

next를 호출하거나, 반복을할때 generator는 다음 yield를 호출하기 전까지 정지한 것과 같다. 다음의 예시를 보자

## 코드 : 
def my_iterator() :
    my_list = [1,2,3,4,5,6,7,8,9,10]
    for i in range(len(my_list)) :
        yield my_list[i]

a = my_iterator()

next(a)
next(a)

## 출력 :
currently were 0
currently were 1

Dictionary의 반복

이걸 배우기 까지 너무나도 많은 길을 걸어왔다. 우리들이 Advanced-For를 배울때까지 기다린 Dictionary에게 경의를 표하자 아래의 코드로 확인하자

## 코드 :
students = {"P_01":"CHEEL","O_02":"GLAADOS","R_03":"STEENLY"}

for index, value in students.items() :
    print(index, value)

## 출력 :
P_01 CHEEL
O_02 GLAADOS
R_03 STEENLY

students.items()는 우선 iterator는 아니다. 이는 dictionary의 특징을 생각하면 잘 알수 있는데, dictionary는 순서가 없다는것이다. 따라서 a = students.items()를 했을때 a는 dict_item이라는 객체로 출력됨을 알 수 있다.

이번 시간에는 iterable 한 객체와 나만의 Iterator를 생성하는 법, 늦게나마 Dictionary를 반복하는 방법과 Advanced for를 사용하는 방법을 배웠다. 이제 Python과 짱친먹을 시간도 얼마 남지 않았다. 다음 시간에는 내포(Comprehension)에 대해서 알아보도록 하자

주석은 프로그래밍에서 어려운 문법을 가지고 있는 것도 아니고, 프로그램의 실행시간의 지대한 영향을 끼치는 것도 아니다. 그런데 왜 필자는 주석을 Python과 친해지기 포스팅이 아닌 Advanced버전인 Python과 매우 친해지기에 올렸을까? 아래의 두 가지 이유가 있다.

1. 주석은 프로그래머들 사이의 협업의 규약이기에 매우 중요하므로, 이는 어느 정도 실력이 보증된 프로그래머가 작성해야된다.
2. 필자는 까먹었다.

자 그럼 Python세계의 주석을 알아보도록 하자

주석(Comment)

주석은 프로그램의 실행에 영향을 미치지 않으며, 프로그래머가 필요에 의해서 코드에 추가적인 정보를 입력하는 것이다.

Python에서는 다음과 같은 방법으로 주석을 남길 수 있다.

한 줄 주석(#)

def comment(value) :
    print(value)	# 한줄의 주석을 추가합니다.

여러 줄 주석(''' ~ ''')

def comment(value) :
    print(value)

'''
여러줄의 주석을 추가하는
방법은 작은따옴표
세개를 연달아 쓰는것입니다.
끝내는 방법도 동일합니다.
'''

훌륭한 주석에 대한 고찰

좋은 주석은 무엇일까? 보기에 번잡스럽지 않으면서도, 필요한 내용을 정확하게 알려주는 주석이 좋은 주석이라고 할 수 있겠다. 대표적으로 아래와 같은 주석이 많이 쓰인다.

① 머리글 : 프로그램의 제작자, 저작권, 생성일, 변경 일등을 기술한다.

#######################
# Python calc program
# Python 3.8.4
# written by 리덕토 at 2021_04_10
# This code is protected by XXX
# 
# revise-1 2021_04_XX : add sub function
# revise-2 2021_05_XX : add div function
#######################

def add(val1, val2):
    return val1 + val2

def sub(val1,val2) :
    return val1-val2

def div(val1,val2) :
    return val1/val2

② 함수 동작 주석 : 함수의 파라미터, 리턴 값, 동작 방식을 설명한다.(프로그래머도 사람이라, 자연어 기술이 더 읽기 좋다.)

# function_name : do_something
#
# purpose : to get property of user's request 
#
# parameters : 
#  - req : String, should include ":"
#  - parameter : Integer, 1 = length of seperated req, 2 = sum of seperated req
#
# return : Integer, length of handled data or sum of that
#
# Warn : req should only contained Integer value and ":" 
 
def do_something(req, parameter) :
   	data = data.strip(":")
    if(parameter == 1) :
        return len(data)
    elif(parameter == 2) :
    	sum_data = 0 
        for i in range(len(data)) :
        	sum_data += data[i]
        return sum_data

좋은 주석을 단다는 건 어려운 일이다. 주석을 다는 규약이 없는 조직이라는 필연적으로 프로그래머 자기 자신 나름대로의 주석 습관이 생기기 마련이다.

누군가는 모든 코드에 주석을 달 것이고(이건 아닌 거 같다.) 누군가는 나만 보려고 주석 없는 코드를 만들 수도 있다.

다만 좋은 형상관리 도구들(Github)들을 가보면 모두가 사용하는 코드에 주석이 한 줄도 없는 경우는 찾아보기 힘들다.

매너 있는 프로그래머가 되기 위해서, 또 게으른 우리 자신을 위해서 주석을 달아두는 건 분명 도움되는 습관이다. 다음 시간은 Iterator에 대해서 알아보자

오랜만이다. 한 3일 만에 글을 쓰는 것 같은데 바쁜 현생을 살고 왔다. 이번 시간에는 Python에 존재하는 여러 가지 예약어에 대해서 알아보도록 하자. 이미 우리가 배운 것도 많이 있으며 어? 이건 새로 보는 건데? 하는 건 사용법으로 알아보자. 

※ 주의 ※ 이번글은 굳이 다 읽은 필요가 없다.

and

논리연산 and, 2개의 bool값을 받아 둘 다 참이면 True, 하나라도 False인 경우 False 가 된다. 

>>> a = 3
>>> b = 5
>>> print(a>2 and b>4)
True
## a>2와 b>4는 둘다 True라 둘을 and 한 결과도 True이다.

>>> print(a<2 and b>4)
False 
## a<2가 거짓이기 때문에 비록 b>4가 True더라도 and의 결과는 False이다.

as

별칭을 지정한다. f객체를 open하며 사용하거나, import 되는 모듈의 이름을 별칭으로 만들기도 한다.

import random as r

print(r.randrange(0,10))

with open("filename.txt","r") as f:
    print(f.read())

assert

가정설정문, 특별한 경우를 지정하여 Exception을 발생시킨다.(값 검증에 사용된다.) 여기서 발생되는 Exception은 AssertionError라고 한다. 

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

loc = int(input("몇 번째 과일을 출력하시겠습니까? : "))
try :
    assert len(fruits)>loc-1, "배열초과"
    print(fruits[loc])
except AssertionError :
    print("올바른 값을 입력")

## 실행 :
몇 번째 과일을 출력하시겠습니까? : 2
strawberry

## 재실행 :
몇 번째 과일을 출력하시겠습니까? : 5
올바른 값을 입력

async - await

import asyncio와 같이 사용되며, 비동기 처리방식을 만들 때 사용된다. 함수를 정의할 때 async를 지정하여 네이티브 코 루틴을 생성할 수 있고, await로 해당 코 루틴이 끝나는 것을 기다릴 수 있다.(추후에 자세한 내용 포스팅)

## 코드 : 
import asyncio

async def add_five(val) :
    print(val,"is val")
    await asyncio.sleep(1.0)
    return val+5

async def add_print(val) :
    print(await add_five(val))

loop = asyncio.get_event_loop()
loop.run_until_complete(add_print(4))
loop.close()

## 출력 : 9는 1초후에 출력된다.
4 is val
9

break

가장가까운 반복문을 중단한다

## 코드 :
for i in range(10) :
	if(i>2) :
		break
	print("HELLO",i)

## 출력 :    
HELLO 0
HELLO 1
HELLO 2

class

클래스를 정의한다.(성의 없다.)

class dog :
    name = ""
    owner = ""

continue

가장 가까운 반복문을 다음 step으로 강제 이동시킨다.

## 코드 : 
for i in range(5) :
	print("loop is not end")
	if(i>2) :
		continue
	print("HELLO",i)

## 출력 : 
loop is not end
HELLO 0
loop is not end
HELLO 1
loop is not end
HELLO 2
loop is not end
loop is not end

def

함수를 정의한다.(성의 없다.)

def my_foo(value):
    print(value)

del 

변수 / 객체를 삭제한다. 삭제된 변수 / 객체는 접근할 수 없다.(원칙상 그렇다. 취약점으로 접근하는 경우는 논외로 하자)

## 코드 :
a=3
print(a)

del a
print(a)

## 출력 :
3
Traceback (most recent call last):
  File "C:/Users/82109/Desktop/123.py", line 5, in <module>
    print(a)
NameError: name 'a' is not defined

finally - else

try - except과 같이 사용되며, finally 예약어는 try 나 except에서 실행되고 실행될 블록을, else는 try에서 에러가 검출되지 않을때 실행될 블럭을 지시한다.

## 코드 :
fruits = ["apple","orange","strawberry","kiwi"]

try :
    print(fruits[3])
except IndexError:
    print("인덱스 에러입니다.")
else :
    print("인덱스 에러가 아닙니다.")
finally :
    print("2케2케해서 출력은 끝입니다.")
## else - finally 중 하나만 써도 되지만, 둘다 쓴다면
## else 다음 finally가 나와야한다.

## 출력 : 
kiwi
인덱스 에러가 아닙니다.
2케2케해서 출력은 끝입니다.

from - import

다른 모듈을 import 한다. from과 같이 사용하여 대상을 지정할 수 있고, 이렇게 가져온 모듈은 앞의 클래스 명의 생략이 가능하다.

## 코드 :
import random
print(random.randrange(0,10))

from random import *
print(randrange(0,10))

from random import randrange
print(randrange(0,10))

## 출력 : 
3
8
8

for

반복을 지시하는 예약어, iteratable 한 객채를 대상으로 반복자를 지정하여 반복한다. 

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

print("일반적인 for문")
for i in range(len(fruits)) :
    print(fruits[i])

print("\nAdvanced for문")
for fruit in fruits :
    print(fruit)

## 출력 :
일반적인 for문
apple
orange
strawberry
kiwi

Advanced for문
apple
orange
strawberry
kiwi

global

변수를 전역 변수로 지정한다.

## 코드 :
fruits = ["apple","orange","strawberry","kiwi"]

def print_fruits() :
    global fruits
    print(fruits)

print_fruits()
   
## 실행 : 
['apple', 'orange', 'strawberry', 'kiwi']

if - elif - else

프로그램 제어문으로 프로그램의 분기를 생성한다.

## 코드 :
value = int(input("값을 입력하세요 : "))

if(value>50) :
    print("50이상의 값")
elif(value>30) :
    print("30이상의 값")
else :
    print("뭐죠")
   
   
## 실행 : 
값을 입력하세요 : 60
50이상의 값

## 재실행
값을 입력하세요 : 40
30이상의 값

## 재실행
값을 입력하세요 : 20
뭐죠

in 

포함을 검사하는 예약어. [원소] in [자료구조]로 사용하여 bool값(True, False)을 반환한다. not과 같이 사용하여 not in으로 사용할 수 있다.

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

if("apple" in fruits) :
    print("apple은 있다")
    if("app" in fruits[fruits.index("apple")]) :
        print("물론 app도 있다")

## 출력 : 
apple은 있다
물론 app도 있다

is

동등함을 검사하는 예약어 == 과 다른 점은 같은 값을 가리키느냐(==), 객채를 가리키느냐(is) 차이이다. not과 같이 사용하여 is not으로 쓸 수 있다.

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

if("apple" is fruits[0]) :
    print("그렇죠 같습니다")

## 출력 :
그렇죠 같습니다

lambda

Python에서 익명 함수를 생성하는 예약어이다. (자세한 사용법은 포스팅 예정)

my_foo = lambda x:x+3
print(my_foo(3))

None

값이 없다는 의미이다. NoneType이라는 자료형에 하위 객체인데, 다른 언어의 null처럼 사용된다

nonlocal

인라인 함수에서(Nested Function) 자기 위에 존재하는 변수를 지정할 때 사용된다.(추후 자세한 내용 포스팅)

## 코드 : 
def outer_fun(crit) :
    data = "outer_fun_data"
    def inter_fun() :
        nonlocal data
        data = "inter_fun_data"
        print(data)
    if(crit == 1) :
        inter_fun()
    print(data)

crit = int(input())
outer_fun(crit)

## 실행 :
기준을 입력하세요(1:nonlocal) : 0
outer_fun_data

## 재실행 :
기준을 입력하세요(1:nonlocal) : 1
inter_fun_data
inter_fun_data

not

논리 연산 not, 2개의 bool값을 받아 True - False를 반전 시킨다. 

>>> a=3
>>> a>3
False

>>> not a>3
True
## not의 결과는 반전이다.

or

논리연산 or, 2개의 bool값을 받아 둘 중 하나라도 True인 경우 True, 나머지는 False가 된다.

>> a = 3
>> b = 5
>> print(a>2 or b>4)
True
## b<4가 False이지만, a>2가 True 이기때문에 둘의 or는 True이다.

>> print(a<2 or b<4)
False 
## 둘다 False인 경우 or의 결과또한 False이다.

pass

실행할 코드가 없음을 명시한다. 이는 except같이 필수적으로 무언가 실행을 지시하여야 하나, 아무 처리를 하지 않을 때 사용된다.

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

loc = int(input("몇 번째 과일을 출력하시겠습니까? : "))
try :
    print(fruits[loc])
except IndexError :
    pass

## 실행 : 
몇 번째 과일을 출력하시겠습니까? : 1
orange

## 재실행 :
몇 번째 과일을 출력하시겠습니까? : 5

raise

강제 Exception을 발생시킨다.

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

loc = int(input("몇 번째 과일을 출력하시겠습니까? : "))
try :
    if(loc-1 > len(fruits)) :
        raise IndexError
    print(fruits[loc])
except IndexError :
    print("올바른 값을 입력")

## 실행 : 
몇 번째 과일을 출력하시겠습니까? : 1
orange

## 재실행 :
몇 번째 과일을 출력하시겠습니까? : 5
올바른 값을 입력

return 

함수 실행결과의 반환 값을 지정한다.

## 코드 : 
def add_five(value) :
    return value+5

print(add_five(3))

## 출력 :
8

try - except

try 코드 블록에서 에러가 발생할 블록을 검사하여 에러를 except 코드블록에서 처리한다.

## 코드 :
fruits = ["apple","orange","strawberry","kiwi"]

try :
    print(fruits[6])
except IndexError:
    print("인덱스 에러입니다.")

## 출력 :
인덱스 에러입니다.

with

객체에 대한 __enter__()와 __exit__()을 자동으로 실행시켜준다. 정말 훌륭한 기능은 file 객체의 f.open()과 f.close()를 자동 호출해준다는 점이다.

with open("filename.txt","r") as f :
    print(f.read())

while 

반복을 지시하는 예약어 조건이 참 일동 안 loop를 반복한다.

## 코드 : 
fruits = ["apple","orange","strawberry","kiwi"]

cnt = 0
while(cnt<len(fruits)) :
    print(fruits[cnt])
    cnt+=1

## 출력 : 
apple
orange
strawberry
kiwi

yield

generator 객체의 다음 반환될 값을 설정한다.(추후에 자세히 포스팅 예정) yield from으로 다른 iteratable 한 객체를 반환할 수 있다.

## 코드 :
def my_generator() :
    a=[1,2,3]
    for i in range(len(a)) :
        yield a[i]

my = my_generator()
print(next(my))
print(next(my))
print(next(my))

## 출력 :
1
2
3

파이선 3.8을 기준으로 만든 35개의 예약어 사전이다(맞겠지? 다 적긴 한 거 같은데...). 필요한 게 생길 때 와서 보면 좋을 것 같다. Python에는 내장 모듈로 keyword를 제공한다. keyword는 파이선에서 제공되는 여러 가지 예약어와 관련된 함수를 정의해두었으니, 사용해보는 것을 추천한다.