[Python] 기본 문법 - 함수

👉 함수 기본 구조

def 함수명(매개변수):
    <수행할 문장1>
    <수행할 문장2>
    ...
    return 결과값

def add(a, b):  # 매개변수 
    return a + b 

add_result = add(3,4) # 인수
print(add_result) # 7

매개변수(parameter) 는 함수에 입력으로 전달된 값을 받는 변수를 의미하고,
인수(argument) 는 함수를 호출할 때 전달하는 입력값을 의미한다. 

 

입력값과 결과값 모두 있는 합수

def add(a, b): 
    result = a + b 
    return result
    
 result = add(3,4)
 print(result) # 7

 

입력값이 없는 합수

def greeting():
  return "What's up?"

r = greeting()
print(r) # What's up?

 

결과값이 없는 합수

def user_info(name,age):
  print('Name:',name)
  print('Age:',age)

user_info('amy',20) 
# Name: amy
# Age: 20

 

입력값도 결과값도 없는 합수

def greeting():
  print("What's up?")

greeting() # What's up?

 

---

 

👉 매개변수 

매개변수 지정하여 호출

def add(a,b):
    return a+b
 
print(add(a=2,b=3), add(b=3,a=3)) # 5 6

 

* args

• 함수가 입력값을 몇개 받을지 모를 때 매개변수로 ' *매개변수 ' 를 사용한다
• args는 인수를 뜻하는 argument의 약자로 관례적으로 자주 사용한다.

def 함수이름(*매개변수): 
    <수행할 문장>
    ...

def add_args(*args):
  result = 0
  print(args)
  for i in args:
    result += i

  return result

result = add_args(1,2,3,4,5)
print(result)
# (1,2,3,4,5)
# 15

def add_mul(choice, *args): 
    if choice == "add": 
        result = 0 
        for i in args: 
            result = result + i 
    elif choice == "mul": 
        result = 1 
        for i in args: 
            result = result * i 
    return result 

result = add_mul('add', 1,2,3,4,5)
print(result) # 15

매개변수 args는 튜플이 되고 모든 인수값들이 그 튜플에 저장된다.

 

**kwargs

def print_kwargs(**kwargs):
  print(kwargs)

print_kwargs(name='amy',age=20) # {'name': 'amy', 'age': 20}

매개변수 kwargs는 딕셔너리가 되고 모든 key = value 형태의 결괏값이 그 딕셔너리에 저장된다.

 

매개변수에 초기값 설정

• 초깃값으로 설정하고 싶은 변수들은 뒤쪽에 있어야 한다.

def user_info(name, age, is_programmer=False):
  print('이름은 %s 입니다.' % name)
  print('나이는 %d살 입니다.' % age)

  if is_programmer:
    print('프로그래머 입니다.')
  else:
    print('프로그래머가 아닙니다.')


user_info('amy', 20)
# 이름은 amy 입니다.
# 나이는 20살 입니다.
# 프로그래머가 아닙니다.

user_info('ann', 21, True)
# 이름은 amy 입니다.
# 나이는 20살 입니다.
# 프로그래머가 입니다.

 

---

 

👉 함수에서 retrun

• return 은 함수에서 처리된 결괏값을 반환한다.
• return 결괏값은 항상 하나이다
• return 에 여러개 값은 튜플로 반환한다.

def add_and_mul(a,b): 
  return a+b, a*b

result = add_and_mul(3,4)
print(result) # (7, 12)

add_res, mul_res = add_and_mul(3,4)
print(add_res, mul_res) # 7 12

 

• 특별한 상황에서 함수를 빠져나가고 싶다면 return을 단독으로 써서 함수를 즉시 빠져나갈 수 있다.

def print_id(id): 
    if id == '0': 
       return 
    print("id는 %s 입니다." % id)

print_id('0')
print_id('777') # id는 777 입니다.

 

---

 

👉 지역(Local) 변수와 전역(Global) 변수

지역변수와 전역 변수

• 함수 안에서 만든 변수(지역 변수)는 함수 안에서만 살아있다가 함수 코드가 실행 종료되면 변수도 같이 사라진다.
• 함수 외부에서 만든 변수(전역 변수)는 프로그램이 실행되어 있는 동안에 계속 살아있다.

a = 1 # 전역 변수
def vartest(a):
    a = a +1 # 지역 변수
    return a

result = vartest(a)
print(result, a) # 2, 1

 

함수 안에서 함수 밖의 변수를 변경하는 방법

• return 사용하기

a = 1 
def vartest(a): 
    a = a +1 
    return a

a = vartest(a) 
print(a) # 2

 

• global 명령어 사용하기

a = 1 
def vartest(): 
    global a 
    a = a+1

vartest() 
print(a) # 2

global을 사용하면 함수가 외부 변수에 종속적이다.
따라서 함수는 독립적으로 존재하는 것이 좋기 때문에 global 명령어를 사용하지 않는 것이 좋다고 한다.
가급적이면 첫번째 방법을 사용하자.

 

---

 

👉 lambda 함수

• 함수를 생성할 때 사용하는 예약어로 def와 동일한 역할을 한다.
• lambda 예약어로 만든 함수는 return 명령어가 없어도 결괏값을 돌려준다.

lambda 매개변수1, 매개변수2, ... : 매개변수를 이용한 표현식

add = lambda a,b: a+b
result = add(3,4)
print(result) #7

def print_func(func,x):
  print(func(x))

print_func(lambda x:x+3, 1) # 4

 

👉 중첩 함수 (Nested Function)

• 함수 안에 정의된 함수

def func(a):
  def nested_func():
    nonlocal a
    a = a + 1
    return a
  return nested_func()

print(func(2)) # 3

nonlocal은 중첩함수 한단계 바깥에 있는 변수를 가져온다.  

 

👉 generator와 yield

yield

def list_pow(n):
  pow_list = []
  while n>0:
    pow_list.append(n**2)
    n -= 1
  return pow_list

for i in list_pow(5):
  print(i, end=' ')
# 25 16 9 4 1
print()

print(list_pow(5)) # [25,16,9,4,1]

def yield_pow(n):
  while n>0:
    yield n**2
    n -= 1


for i in yield_pow(5):
  print(i, end=' ')
# 25 16 9 4 1
print()

print(yield_pow(5)) # <generator object yield_pow at 0x7f7aa00684a0>

yield 키워드를 사용하면 generator를 반환한다.

 

generator

• 여러 개의 데이터를 미리 만들어 놓지 않고 필요할 때마다 하나씩 만들어 낼 수 있는 객체

import time

def list_pow(n):
  pow_list = []
  while n>0:
    time.sleep(1)
    pow_list.append(n**2)
    n -= 1
  return pow_list

for i in list_pow(5):
  print(i)

# (5초 경과)
# 25
# 16
# 9
# 4
# 1

원소 하나를 만드는데 1초가 걸린다. for 루프로 list 원소를 순회할 때 5초가 흐른 후에 25,16,9,4,1이 한번에 출력 된다.

 

import time

def yield_pow(n):
  while n>0:
    time.sleep(1)
    yield n**2
    n -= 1


for i in yield_pow(5):
  print(i)

# (1초 경과)
# 25
# (1초 경과)
# 16
# (1초 경과)
# 9
# (1초 경과)
# 4
# (1초 경과)
# 1

1초 후에 25가 출력되고, 1초 후에 16이 출력되고...
각 원소는 1초의 간격을 두고 출력된다.

결과값을 나누어서 얻을 수 있기 때문에 성능 측면에서 이점이 있다.
return 키워드를 사용할 때는 모든 결과값을 메모리에 올려놓아야하는 반면, yield 키워드를 사용할 때는 결과값을 하나씩 메모리에 올려 놓는다. 따라서 메모리 효율적이다.

 

yield from

• list를 generator로 변환

def ex_yield_from(ex_list):
  yield from ex_list

for i in ex_yield_from([25,16,9,4,1]):
  print(i,end=' ') 
# 25 16 9 4 1

 

generator comprehension

gen = (i**2 for i in range(5,0,-1))

print(gen) 
# <generator object <genexpr> at 0x7f59e55ca4a0>

for i in gen:
  print(i, end=' ')
# 25 16 9 4 1

 

---

 

참고

• 점프 투 파이썬
• https://fastcampus.co.kr/dev_online_computer  
• https://www.daleseo.com/python-yield/   (generator와 yield 부분)