20210107_ Python 입문5, 함수,*args,**kwargs, parameter hint, lambda

Python 입문 05, 함수,args,*kwargs, parameter hint, lambda

---

Python 함수 정의 및 lambda(람다) 사용

 

1. 함수

  반복적, 중복 프로그래밍을 피할수 있음

1) 함수 정의(선언) 방법

• 구조

def 함수명(매개변수parameter):
    code    

 

• 리턴값이 없는 함수

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

hello("python!")
# world 만 붙여 출력만 하는 함수라서 값이 지정 되어 있지 않아 type()로 데이터 형식 확인 안됨

 

• 리턴값이 있는 함수

def hello_return(world):
    v = "hello" + str(world)
    return v

print(hello_return("python!!!"))
print(type(hello_return("python!!!")))
# 리턴 값이 할당이 되어서 type()로 데이터 형식 확인 가능

 

• 다중 리턴 함수

  여러 리턴값들을 가지는 함수

def func_mul(x):
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return y1, y2, y3
# parmeter x하나 넣으면 리턴 3개 값이 나옴
val1, val2, val3 = func_mul(100)
# 변수 3개에 한개의 라인으로 선언
print(type(val1), val1, val2, val3)
# type() 확인하면 그대로 int 나옴

 

• 다중 리턴 함수 + 데이터 타입 반환

  다중 리턴 함수에서 리턴 값들을 다른 타입의 데이터로 반환하게 하는 것

# list 형 (for반복문 연계)
def func_mu2(x):
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return [y1, y2, y3] # [ ] 사용

# tuple 형 (for반복문 연계)
def func_mu3(x):
    y1 = x * 100
    y2 = x * 200
    y3 = x * 300
    return (y1, y2, y3) # ( ) 사용

 

2) *args (arguments), **kwargs(keyword arguments) 사용

  기본 매개변수(parameter)가 필수 사항이면 args, *kwargs 는 선택사항으로 두고 매개변수(parameter)가 몇개 올지 모르는 상황에서 사용

  단, args 는 리턴 시키거나, print 전까진 tuple 형태, *kwargs는 dict 형태로 리턴 됨, 그리고 그냥 print()형태 함수로 하면 표현은 tuple, dict 형태로 나오는데 type은 none type임

• *args 기본 구조

def args_func(*args):  
    print(type(args))  

args_func('kim')
# 선언만 되어도 기본 튜플 타입

def args_func(*args):  
    return args

print(type(args_func('kim')))
# 리턴 해도 기본 튜플 타입

def args_func(*args):  
    print(args)

args_func('kim')
print(type(args_func('kim'))
# 출력은 튜플 형태로 보이나, 출력자체는 none type

 

• **kwargs 기본 구조

def kwargs_func(**kwargs):
    print(kwargs)

kwargs_func(name1="kim", name2="park", name3="lee")
# dict 형태로 출력 

 

• *args, **kwargs + for 문 활용

def args_func(*args):  
    for t in args:
        print(t)

args_func('kim', 'Park', 'Lee')
# 차례 대로 kim , park , lee 출력

def kwargs_func1(**kwargs):
    for i, v in kwargs.items():
        print(i, v)

kwargs_func1(name1="kim", name2="park", name3="lee")
# dict형태로 만들어진 key - value 묶음으로 차례대로 출력

 

3) enumerate 함수 활용

  입력으로 받은 데이터(순서있는 데이터 : str,tuple,list )를 인덱스 값을 포함하는 enumerate 객체로 리턴

  enumerate 객체 : (인덱스 , 값)

• 구조

def args_func(*args):  
    for i, v in enumerate(args): # 인덱스 뽑는 거니까 i, v 두개
        print(i, v)

args_func('kim', 'Park', 'Lee')
# 출력 : 0 Kim , 1 Park , 2 Lee 차례대로 하나씩

 

• enumerate + range 활용

def args_func(*args):  
    for i, v in enumerate(range(10)):
        print(i, v)

args_func('kim')
# 뭘 넣든 그냥 0~9 인덱스 와 0~9 값이 묶여 객체로 리턴

 

4) 중첩함수(클로저)

  클로저 형태로 하면 변수의 선언 줄이고 메모리 관리 효율적

def func(num):
    def func_in_func(num): # 1. 내부 함수 선언만 한 상태
        print(">>>", num)         # 4. 내부 함수에 들어온 20000을 넣어 출력
    print("in func")       # 2. 외부 함수에 값 들어오고 in func 출력
    func_in_func(num + 10000) # 3. 내부 함수에 외부함수에 넣은 값을 +10000 해서 넣고

func(10000)  # 20000       

5) Parameter Hint (파라미터 힌트)

• ctrl + shift + space : 힌트 보기

• 구조

def func_mul(x : int) -> list: # 명시적으로 입력값 int -> 출력값 list 라고 알려 줄 수 있다.
    y1 = x * 100
    return [y1]

print(func_mul(5))

---

---

 

2. lambda 식 (람다 식)

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

• 함수의 객체 생성(선언만 하더라도 print, type에서 확인 가능) -> 메모리 할당

• 람다 즉시 실행 -> 메모리 초기화

1) 구조

lambda_1 = lambda num: num * 10  
# lambda num 부분이 입력 부분이고 : num * 10 이 출력 부분

print(lambda_mul_10(10))            
# 단순히 코드의 길이를 줄이는게 아니고 빠르게 처리하는데 의미가 있음
print(type(lambda_mul_10(10))) 
# type 확인해 보면 int로 바로 가져옴 중간에 함수 fuction으로 메모리 할당 없이 가능

 

• 매개변수를 함수, lambda로 받는 경우

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

func_final(10, 10, lambda_mul_10) # 기존의 함수에 10이 들어가서 현재 함수에서 계산됨

print(func_final(10, 10, lambda x : x * 1000)) 
# 그런데 그냥 람다 형식도 된다.함수 선언 없이 빠르고 메모리 할당도 없이 좋다.

하루평

: 눈이 엄청 왔다. 런닝은 포기하고 홈트레이닝으로 해야 할듯하다. 강의는 class도 들었는데 여기서 부터 조금 개념 이해가 조금 힘들어지긴 하는데 구글링, 유튜브로 해결하고 있다. 클래스는 여기 글에 올리기에는 좀 그래서 내일 글에 올릴 예정이다.