함수식 및 람다(lambda)

# 함수

(1)

def hello(world):
    print("Hello", world)

hello("Python") # Hello Python
hello(7777) # Hello 7777

(2)

def helllo_return(world):
    val = "HEllo" + str(world)  #( 문자열이랑 숫자열 + 안됨! 그래서 형변환 해주기. )
    return val

str = helllo_return("Python~!!") 
print(str) # HElloPython~!!

(3) (다중 return)

def func_mul(x):
    y1= x*100
    y2= x*200
    y3= x*300
    return y1, y2, y3

val1, val2, val3 = func_mul(100)
print(val1, val2, val3) # 10000 20000 30000

(4) (데이터 타입 반환)

def func_mul2(x):
    y1= x*100
    y2= x*200
    y3= x*300
    return [y1, y2, y3] 

lt = func_mul2(100)
print(lt, type(lt)) # 10000, 20000, 30000] <class 'list'>

def func_mul3(x):
    y1= x*100
    y2= x*200
    y3= x*300
    return (y1, y2, y3)

lp = func_mul3(100)
print(lp, type(lp)) # (10000, 20000, 30000) <class 'tuple'>

(5) args, kwarges

- 1개 일 때는 튜플로, 2개일때는 딕셔너리로 받음

- *args -> 몇개의 parameter를 넣든 인자들이 tuple로 만들어짐.

def args_func(*args):
    print(args)
    print(type(args))
    
    for i,v in enumerate(args): #( enumerate : 인덱스를 만들어서 순회(iterate) )
        print(i,v)
    
    for i,v in enumerate(range(5)):
        print(i,v)

args_func("KIM")

# ('KIM',)
#  <class 'tuple'>
#  0 KIM
#  0 0
#  1 1
#  2 2
#  3 3
#  4 4

args_func("KIM", "Park")

# ('KIM', 'Park')
#  <class 'tuple'>
#  0 KIM
#  1 Park
#  0 0
#  1 1
#  2 2
#  3 3
#  4 4

args_func("KIM", "Park", "Lee") 

# ('KIM', 'Park', 'Lee')
#  <class 'tuple'>
#  0 KIM
#  1 Park
#  2 Lee
#  0 0
#  1 1
#  2 2
#  3 3
#  4 4

kwargs

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

kwargs_func(name1 ="Hong") # {'name1': 'Hong'}
			   # name1 Hong
kwargs_func(name1 ='Kim', name2 ='Park', name3 ='Lee') 

# {'name1': 'Kim', 'name2': 'Park', 'name3': 'Lee'}
#  name1 Kim
#  name2 Park
#  name3 Lee

전체 혼합

def example_mul(arg1, arg2, *args, **kwargs):  # (arg1, arg2 -> 필수적으로 함수 호출할 때 써야 하는 것, *args, **kwargs -> 가변 인자)
    print(arg1, arg2, args, kwargs)

example_mul(10,20) # 10 20 () {}  
example_mul(10,20, 'park', 'kim') # 10 20 ('park', 'kim') {}
example_mul(10,20, 'park', 'kim', age=1, age2=35) # 0 20 ('park', 'kim') {'age': 1, 'age2': 35}

중첩함수(클로저)

- 파이썬_데코레이터 클로저

def nested_func(num):
    def func_in_func(num):
        print('>>>',num) # 출력만 있을 뿐 실행은 x, 최종실행
    print("in function")
    func_in_func(num+1000) # 실행은 여기서!

nested_func(1000) # in function
		  #  >>> 2000

(6) (hint)

힌트 적으면 함수 사용할 때 명시적으로 함수의 입력값과 출력값이 뭔지 알려줄 수 있음.

def func_mul3(x : int)-> list:  
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return [y1, y2, y3]

print(func_mul3(5)) # [500, 1000, 1500]

# 람다식

- 메모리 절약, 가독성 향상, 코드 간결

- 함수는 객체 생성 -> 리소스(메모리) 할당

- 람다는 즉시 실행(Heap 초기화) -> 메모리 초기화 됨

- 람다식은 데이터 전처리나 데이터베이스, 웹에서 사용할 게시판데이터 들을 대량으로 가져와서 날짜수정-내용수정-형태소분석-새로운 문자열만들기 ... 등에 좋음

- 일반적 함수 -> 변수 할당

def mul_10(num : int) -> int:
    return num * 10     #( -> y = num *10 \n return y  해도 되지만, 바로 간단한 식은 바로 return해주면 간결. )
    
var_func =  mul_10
print(var_func) # <function mul_10 at 0x000002546FEC5EE0> ( 함수도 메모리 할당됨. )
print(type(var_func)) # <class 'function'>

print(var_func(10)) # 100

lambda_mul_10 = lambda x : x * 10   #( input -> lambda x, output -> x * 10 )

lambda_mul_10(10)
print('>>>', lambda_mul_10(10)) # >>> 100

def func_final(x, y, func):   #( 매개변수로 함수도 받을 수 있음. )
    print(x * y * func(10))

func_final(10, 10 , lambda_mul_10) # 10000

print(func_final(10, 10, lambda x : x * 1000)) # 1000000 ( 함수를 매개변수로 넘길 때 람다식으로 작성 )