2020.01.23

1. lec01_func.py

# -*- coding: utf-8 -*-
#함수정의와 호출

#함수정의
#형식 : def 함수이름(매개변수들 ,로 분리) :
#들여쓰기가 블럭이므로 들여쓰는 부분이 함수의 본체(body)

def func() :
    pass
#pass: 코드 없이 지나가고자 할 때

#함수호출 : 함수이름()
func()

#함수 #1 : 매개변수 없음, 반환값(return) 없음
def greetings() :
    print("hello")
greetings()

#함수 #2 : 매개변수 있음, 반환값(return) 없음
def print_message(text) : 
    print('-'*30)
    print(text)

print_message("함수를 시작합니다.")

#함수 #3 : 매개변수 없음, 반환값(return) 있음
def get_int() :
    num = int(input('정수를 입력하세요'))
    print(num, '이 입력되었습니다!!')
    return num

a = get_int()
print(a)

#함수 #4 : 매개변수 있음, 반환값(return) 있음
def increment(x) : 
    return x+1

print(increment(3))

################################################################
#반환형태 #1 여러 개의 값을 반환. 튜플로 감싸서 return.
def diff(a,b) :
    return a-b, b-a
print(diff(3,4))

#unpacking
a,b = diff(3,5)
print(a,b)

#반환형태 #2 리스트/딕셔너리/set 등 자료구조 형태로 리턴
def numeric(a,b) :
    return [a+b, a-b, a*b, a/b]

print(numeric(3,6))
print(numeric(3,6)[0])  #반환값이 리스트이므로 인덱싱

#반환형태 #3 함수가 아무것도 반환하지 않을 때 : None이 반환됨.
print(greetings())
print(bool(greetings()))

#false, true, None의 관계
ret_value = greetings()
if(ret_value) :
    print("값이 있습니다.")
else : #false
    if(ret_value is None):
        print("값이 없습니다.")
    else :
        print("값이 0입니다.")

######################################################################
# 인자전달방식 arguments
#1 위치 인자
def minus(a,b) :
    return a-b
print(minus(3,5))
print(minus(5,3))

#2 키워드 인자
print(minus(3,5))
print(minus(b=5,a=3))

#3 기본매개변수값 지정
def alarm(text, count=3):
    for i in range(count) :
        print(text)

alarm('일어나세요')
alarm('일어나세요', 5)
#keyword 인자로 호출 : alarm
alarm(count=2, text='빨리일어나세요')

2. lec02_func_var_args.py

# -*- coding: utf-8 -*-
# 가변인자를 갖는 함수 : variable arguments
# 가변인자 : * args (tuple)
# 가변키워드인자 : ** kworgs (dictionary)

# 인수의 개수가 정해지지 않은 가변인수
def print_args(*args) :
    print(args, type(args))
    #for문을 돌면서 print하기
    for arg in args:
        print(arg)

print_args(1,2,3)
print_args(1,2,3,4,5)

#Quiz : 자연수 가변 개수의 인자를 주면 합을 구하기
def add(*args) :
    ret = 0
    for arg in args:
        ret += arg
    return ret

print(add(1,2,3))
print(add(1,2,3,4,5))

#가변키워드 인자 : 키, 값으로 출력
def print_kwargs (** kwargs) : 
    print(kwargs, type(kwargs))

print_kwargs(count = 2, text = '빨리 일어나세요')

def print_kwargs (** kwargs) : 
    for k, v in kwargs.items():
        print(k, v)

print_kwargs(count = 2, text = '빨리 일어나세요')

#둘 다 사용
def whatever(*args, **kwargs) : 
    print(args)
    print(kwargs)

whatever(1,2,3, a=3) #keyword가 뒤로
whatever(1,2,3, sep='- ', end=' ')
print(1,2,3, sep='- ', end=' ')

3. lec03_func_class.py

# -*- coding: utf-8 -*-
# 객체로서 함수 이름 다루기
# 파이썬에서는 모든 것이 객체이다. 함수도 객체이다.
# 파이썬에서 객체는 변수에 저장된 주소로 호출 a=1 print(a)
# 함수 객체를 담은 변수(주소)를 다른 함수에 인자로 넘겨서 호출
# 함수 안에서 새로운 함수를 만들어서 객체를 리턴할 수도 있음.
# 변수가 함수를 가리킬 수도 있고 함수를 다른 함수의 인자로 전달하거나 리턴할 수도 있다.

#함수정의
def square(x):
    return x*x

#함수도 객체임. <class 'function'>
print(square, type(square)) #<function square at 0x0000013360C694C8> -> 주소 <class 'function'>
a=1
print(a, type(a))

print(square(3))

# 함수 객체를 변수에 저장.
a=square
print(a(3)) #파이썬에서 객체는 변수에 저장된 주소로 호출됩니다.

#######################################################
def mantra():
    print('파이썬에서는 함수도 객체입니다')
#함수호출방법 #1
mantra()

#함수호출방법 #2
#함수객체를 변수에 저장
x=mantra
#변수를 통해 함수를 호출
x()

#함수호출방법 #3
def run_func(func):
    func()
#예를들어 a=1일때
run_func(mantra)  #1
run_func(x)       #a

#함수호출 : 리스트에 넣어서 
def add(a,b):
    return a+b
def aub(a,b) :
    return a-b
def multi(a,b):
    return a*b
def div(a,b):
    return a/b

func_list = [add, aub, multi, div]
#Qize. 1, 3이 있다. 사칙연산을 해보시오. func_list를 이용해서
for func in func_list :
    print(func(1, 3))

#list의 각각 원소에 함수를 적용하는 함수를 정의
#square를 적용하고 싶은 경우
# [1,4,9,16,25]

list_a = [1,2,3,4,5] 
def func_map(func, plist) :
    list_b = []
    for param in plist :
        list_b.append(func(param))
        print(func(param))
    return list_b

list_square = func_map(square, list_a)
print(list_square)

4. lec04_recursive.py

# -*- coding: utf-8 -*-

#재귀함수. recursive
# factorial = n! = 1 *2* 3* ...* n
#3!=1*2*3
#4!=3! *4 
def factorial (n) :
    if n==1:
        return 1
    else :
        return (n * factorial(n-1))

print(factorial(3))
print(factorial(4))