TIL#23 함수식 및 람다(lambda)

 

 

 

 

 

함수

 

 

# 파이썬 함수
# 파이썬 함수식 및 람다(lambda)

 

 

함수 사용법

함수 선언 및 사용
다양한 리턴 사용
중첩함수
함수 hint
기타 사용법
람다(Lambda)개념


# 함수 정의 방법
# def function_name(parameter):
#     code

# 예제1
def first_func(w1):   #w1 매개변수(parameter)
    print("Hello, ", w1) #Hello,  Goodboy

word = "Goodboy"

first_func(word) #word 인자(argument)

# 예제2(return)
def return_func(w1):
    value = "Hello, " + str(w1)
    return value

x = return_func('Goodboy2')
#return이 있는 함수는 이 함수에서 넘어오는 결과값으로 반환되는 값을 받을 변수를 선언한 것이다.

print(x) #Hello, Goodboy2

# 예제3(다중반환)

def func_mul(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return y1, y2, y3

x, y, z = func_mul(10) #언팩킹

print(x, y ,z) #100 200 300

# 튜플 리턴

def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return (y1, y2, y3) #팩킹

q = func_mul2(20)

print(type(q), q, list(q)) #<class 'tuple'> (200, 400, 600) [200, 400, 600]

# 리스트 리턴

def func_mul2(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return [y1, y2, y3]


p = func_mul2(30)

print(type(p), p, set(q)) #<class 'list'> [300, 600, 900] {200, 600, 400}

# 딕셔너리 리턴

def func_mul3(x):
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return {'v1': y1, 'v2': y2, 'v3': y3}


d = func_mul3(30)
print(type(d), d, d.get('v2'), d.items(), d.keys())

#<class 'dict'> {'v1': 300, 'v2': 600, 'v3': 900} 600 dict_items([('v1', 300), ('v2', 600), ('v3', 900)]) dict_keys(['v1', 'v2', 'v3'])

 

# 중요
# *args, **kwargs

# *args(언팩킹)튜플 자료형 언팩킹

def args_func(*args): # 매개변수 명 자유 꼭 args라고 할 필요없다.
    for i, v in enumerate(args):  #i는 인덱스/ v는 실제 값
        print('Result : {}'.format(i), v)
    print('-----')
#어떤 자료 묶음이 오더라도 풀어서 사용하는 것.
#튜플 형태가 넘어올 때 많이 사용한다.

args_func('Lee')

Result : 0 Lee
-----

# 매개변수가 args면 하나의 문자형으로 인식한다.
#Result : 0 L
#Result : 1 e
#Result : 2 e
#*가 있으면 튜플 형태의 0번 index로 인식한다.

args_func('Lee', 'Park')

Result : 0 Lee
Result : 1 Park
-----

args_func('Lee', 'Park', 'Kim')

Result : 0 Lee
Result : 1 Park
Result : 2 Kim
-----
#즉, 이것들을 하나의 튜플로 간주했다는 것을 알 수 있다.



# **kwargs(언팩킹) 딕셔너리 자료형 언팩킹

def kwargs_func(**kwargs): # 매개변수 명 자유
    for v in kwargs.keys():
        print("{}".format(v), kwargs[v])
    print('-----')

kwargs_func(name1='Lee')

name1 Lee
-----

kwargs_func(name1='Lee', name2='Park')

name1 Lee
name2 Park
-----

kwargs_func(name1='Lee', name2='Park', name3='Cho')

name1 Lee
name2 Park
name3 Cho
-----



# 전체 혼합
def example(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)

example(10, 20, 'Lee', 'Kim', 'Park', 'Cho', age1=20, age2=30, age3=40)

#10 20 ('Lee', 'Kim', 'Park', 'Cho') {'age1': 20, 'age2': 30, 'age3': 40}

 

 

 

# 중첩함수

def nested_func(num):
    def func_in_func(num):
        print(num)
    print("In func")
    func_in_func(num + 100)

nested_func(100)

#In func
#200



func_in_func(1000)

#'func_in_func'is not defined라고 오류가 나온다.
#이 함수가 정의되는 시점은 메모리에 올라와서 우리가 사용할 수 있게 되는 시점은
#nested_func함수가 호출되고 func_in_func가 실행될 때이다.
#부모함수를 호출하지 않고는 중첩되어있는 자식 함수는 정의되지 않는다.

# 람다식 예제
# 메모리 절약, 가독성 향상, 코드 간결
# 일반적인 함수는 객체 생성 -> 리소스(메모리) 할당
# 람다는 즉시 실행 함수(Heap영역에 저장) -> 메모리 초기화
# 남발 시 가독성 오히려 감소

#일반적인 함수식
#def mul_func(x, y):
#    return x * y

#lambda식 x, y:x*y

# 일반적함수 -> 할당
def mul_func(x, y):
    return x * y

print(mul_func(10, 50)) #500

mul_func_var = mul_func
print(mul_func_var(20,50)) #1000

# 람다 함수 -> 할당
lambda_mul_func = lambda x,y:x*y   #익명함수이기 때문에 변수에 담는다.
print(lambda_mul_func(50,50)) #2500

def func_final(x, y, func):
    print('>>>>', x * y * func(100, 100))

func_final(10, 20, lambda x,y:x*y) #>>>> 2000000
func_final(10, 20, lambda_mul_func) #>>>> 2000000
func_final(10, 20, mul_func_var) #>>>> 2000000

 

# Hint

def tot_length1(word: str, num: int) -> int:
    return len(word) * num


print('hint exam1 : ', tot_length1("i love you", 10)) #hint exam1 :  100


def tot_length2(word: str, num: int) -> None:
    print('hint exam2 : ', len(word) * num) #hint exam2 :  70


tot_length2("niceman", 10)