01_studying. TIL 👨🏻‍💻python

함수 (function)

,

어떠한 반복적이고 중복되는 프로그래밍을 피할 수 있다.
하나의 기능을 하는 함수를 만들어야 좋다.
함수로 전달한 값을 인자(argument)라고 부르며 이는 함수 내에 매개변수(parameter)에 복사한다.

⚠️ 함수 선언 위치
함수를 사용할 위치보다 위에서 선언을 해주고, 선언한 위치보다 아래에서 사용한다.

# 정의(def)

함수는 입력 매개변수(parameter)로 모든 타입을 여러 개 취할 수 있다.
함수 이름은 변수 이름과 동일한 정책
함수 이름은 동사로 시작 추천
매개변수 이름 의미있게 선택 

1
2
def 함수명(parameter):
  (실행할 코드)

# 함수 호출 (call)

함수명()
함수(parameter)

간단한 호출

1
2
3
4
5
def hello(word):
  print('Hello ', word)

hello('Python!')
hello(7777)
1
2
Hello  Python!
Hello  7777

# return

함수는 return 값을 가질 수 있다.
함수가 명시적으로 return을 호출 하지 않으면 None을 호출

1
2
3
4
5
6
def hello_return(word):
  val = "Hello " + str(word)
  return val

str = hello_return("python!!!!!!!")
print(str)
1
Hello python!!!!!!!

다중리턴

1
2
3
4
5
6
7
8
def func_mul(x):
  y1 = x * 100
  y2 = x * 200
  y3 = x * 300
  return y1, y2, y3

val1, val2, val3 = func_mul(100)
print(type(val1), val2, val3)
1
<class 'int'> 20000 30000

다중리턴 (데이터타입 변환)

1
2
3
4
5
6
7
8
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))
1
[10000, 20000, 30000] <class 'list'>

# 힌트 함수

인자를 어떤 타입을 받는지, 출력 값은 어떠한 데이터 타입인지 설명해주는 함수 

1
2
3
4
5
6
7
def func_mul3(x : int) -> list:
  y1 = x * 100
  y2 = x * 200
  y3 = x * 300
  return [y1, y2, y3]

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

# *args

매개변수가 몇개가 넘어올지 모를 때
다양한 매개변수 형태를 받아서 함수의 흐름이 바뀌는 기능을 원할 때
리턴 값은 튜플 형태로 나온다.

1
2
3
4
5
def args_func(*args):
  print(args)

args_func('kim')
args_func('kim','park')
1
2
('kim',)
('kim', 'park')
1
2
3
4
5
6
def args_func2(*args):
  for t in args:
    print(t)

args_func2('kim')
args_func2('kim','park')
1
2
3
kim
kim
park

✔️ enumerate()
인덱스와 값을 같이 출력 해준다.

1
2
3
4
def args_func3(*args):
  for i, v in enumerate(*args):
    print(i, v)
>args_func3('kim', 'park')
1
2
3
# 결과값
>0 kim
>1 park

# **kwargs

매개변수가 몇개가 넘어올지 모를 때
다양한 매개변수 형태를 받아서 함수의 흐름이 바뀌는 기능을 원할 때
딕셔너리형태의 인자를 받고, 딕셔너리형태로 리턴한다. 

1
2
3
4
def kwargs_func(**kwargs):
  print(kwargs)

kwargs_func(name1='kim', name2='Park', name3='Lee')
1
{'name1': 'kim', 'name2': 'Park', 'name3': 'Lee'}

dic에서 items()로 반복문을 사용하여 key와 value를 각각 출력 가능하다.

1
2
3
4
5
def kwargs_func2(**kwargs):
  for k, v in kwargs.items():
    print(k, v)

kwargs_func2(name1='kim', name2='Park', name3='Lee')
1
2
3
name1 kim
name2 Park
name3 Lee

# (인자, args, *kwargs)

혼합해서 사용 할 때
arg1, arg2 : 필수인자
args, *kwargs : 가상인자

1
2
3
4
5
def example_mul(arg1, arg2, *args, **kwargs):
  print(arg1, arg2, args, kwargs)

example_mul(10, 20)
example_mul(10, 20, 'park', 'kim', age1=24, age2=34)
1
2
10 20 () {}
10 20 ('park', 'kim') {'age1': 24, 'age2': 34}

# 일등 시민: 함수

파이썬은 모든 것이 객체(object)
숫자, 문자열, tuple, list, dict, 함수 등 모두가 객체
일등 시민은 함수를 변수에 할당 가능
다른 함수에서 이를 인자로 사용 가능하고 이를 변환 가능

1
2
3
4
5
6
7
8
9
10
# *args, **kwargs 사용해서 인자 결합 가능
def run(func, *args):
  print(func, args)
  # do_sum(1,2,3)
  return func(*args)

def do_sum(*args):
  return sum(args)

run(do_sum, 1, 2, 3)
1
6

# 내부 함수 (중첩함수/inner function)

함수 안에 또 다른 함수 정의 가능
가독성/확장성이 줄어들 수 있으므로 지양
루프나 코드 중복을 피하기 위해 함수 내 복잡한 작업을 한번 이상 수행할 때 유용

1
2
3
4
5
6
7
def do_sum(*args):
  def print_pretty(*args):
    return f'Result: {sum(args)}'

  return print_pretty(*args)

do_sum(1, 2, 3)
1
'Result: 6'

# 클로져

바깥 함수로부터 생성된 변수값을 변경하고 저장 할 수 있는 함수
내부 함수는 클로져 처럼 행동 가능
클로져는 다른 함수에 의해 동적으로 생성 

1
2
3
4
5
6
7
8
9
10
11
12
def do_sum(*args):
  def print_pretty():
    return f'Result: {sum(args)}'

  return print_pretty

a = do_sum(1, 2, 3)
print(a)
b = do_sum(4, 5, 6)
print(b)

# a, b 모두 각각 사용된 인자값을 복사해서 저장중
1
2
<function do_sum.<locals>.print_pretty at 0x7efc56c59d90>
<function do_sum.<locals>.print_pretty at 0x7efc56be52f0>

# 키워드

  • def / call
  • type hinting
  • parameter / argument
  • args / *kwargs
  • 내부함수
  • 일등 시민: 함수
  • 클로져
Share