'23.3.7(화) 파이썬 입문 <12: functions>

1. 파이썬 함수 쌩기초
 정의 : 프로그래머가 이름을 통해서 정의 후 필요할 때마다 호출하는 것.
           즉 반복 되는 코드를 한 번 구현 후 재사용 가능한 코드의 집합

  함수 구현 : 재사용, 루틴(프로시저, 서브루틴)

 

 

2. 함수의 종류  
 2-1 매개변수가 필요한 함수
 2-2 매개변수가 필요하지 않은 함수 
 2-3 결과값을 반환하는 함수(return)
 2-4 결과값을 반환하지 않는 함수

 

---

# 파이썬 함수 생기초 

# 예제 1 : 매개변수가 필요하지 않은 함수

def function1(): #리턴값이 없음
  print('예제1 호출')

# 실행
function1()

# 예제 2 : 매개변수가 필요한 함수

print()

def function2(a, b): # 리턴값이 없음
  print('예제 2 호출', a,b)

#실행
function2(10,20)

# 예제3 결과값을 반환하지 않은 함수
print()

def function3(x,y):
  print('예제 3 호출', x,y)

# 실행
function3(100,200)

# 예제 4 결과값을 반환하는 함수
print()

def function4(x,y):
  return x+y

#실행
r = function4(50,100)
print('예제 4 호출: ', r)

---

3. 프로그래밍 분야에서 함수 사용이 중요함
 - 장점 (1) : 코드의 복잡도가 높아지는 경향을 함수 단계별로 만든다면 프로그램 흐름을 쉽게 만들 수 있음
            (2) : 코드의 재사용성이 가능함
            (3) : 코드의 안전성이 좋아짐 

# 함수의 함수식 및 lambda(람다)

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

# 예제1

def first_func(w):
  print('hello',w)

word = 'Goodboy'

first_func(word)

print()

# 예제2
print()

def second_func(w1):
  value = 'hello , ' + str(w1)
  return value
  
x =  second_func('Goodboy2') 
print(x)

# 예제3 (다중 반환)
print()

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

#unpacking
x,y,z = func_mul(10)
print(x,y,z)

print('>>>')

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

#packing
p = func_mul1(20)
print(type(p), p, list(p))


print('>>>')

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

#packing
p = func_mul2(30)
print(type(p), p, set(p))

print('>>>')

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

#packing
d = func_mul4(40)
print(type(d), d)
print(d.get('v2'), d.items(), d.keys())

## 중요
print()
# *args, **kwargs
# *args는 튜플형으로, *kwargs는 딕셔너리형으로 암기!!!!

# *args(언팩킹)... args에 어떤 가변 인자를 언팩킹하겠다
def args_func(*args): #매개변수 명 자유
  for i, v in enumerate(args): # index, value
    print('result : {}'.format(i), v)
  print('______')

args_func('lee')
args_func('lee', 'park')
args_func('lee', 'park', 'choi')

# kwargs(언팩킹)
print()

def kwargs_func(**kwargs): #매개변수 명 자유
  for v in kwargs.keys():
    print('{}'.format(v), kwargs[v]) #딕셔너리 접근할대는 get 또는 속성으로 접근할 수 있다!!
  print('-----')

kwargs_func(name1 ='lee')
kwargs_func(name1 ='lee', name2 = 'park')
kwargs_func(name1 ='lee', name2 = 'park', name3 =' choi')


# 전체 혼합
print()

def example(args_1, args_2, *args, **kwargs):
  print(args_1, args_2, args, kwargs)

example(10,20,'lee','kim','park', age1 = 10, age2= 20, age3=30)


# 중첩 함수
print()

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

nested_func(100)
# 만약 func_in_finc을 호출했을 때는 오류가 뜸

# lamvbda(람다)
# 람다의 장점: 메모리 절약, 가독성 향상, 코드 간결
# 함수는 객체를 생성하고 리소스(메모리) 항당 됨
# 람다는 즉시 실행하는 함수(heap 영역에 저장) 메모리 초기화
# 남발 시 가독성 오히려 감소됨

print()

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

print(mul_func(50,50))

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

# 람다 함수 -> 할당
# 함수의 이름이 없음. 즉 익명이라서 변수에 담아서 쓰거나 함수의 인자로 넘길 수 있음
print()

lambda_mul_func = lambda x,y:x*y
print(lambda_mul_func(30,50))

#람다와 일반함수 혼합 사용방법
print(">>>")

def func_final(x,y,func):
  print(x*y*func(100,100))
  
func_final(10,20, lambda x,y: x*y)
func_final(10,20, mul_func_var)
func_final(10,20, lambda_mul_func)