파이썬 함수(function)

이미지 출처: https://wikidocs.net/192339

파이썬 함수 및 중요성

파이썬에서 함수는 특정 작업을 수행하는 블록으로, 재사용 가능한 코드 조각입니다.
먼저 우리가 코딩을 하기 전에 함수를 사용함으로써 얻을 수 있는 장점을 알아봅시다.

1.코드의 관리 및 간소화 : 프로그램의 규모가 커지고 많은 기능들이 탑재되어 있기 때문에 코드의 복잡도가 높아지는 경향이 있다. 우리가 아는 프로그램들도 수많은 코드들로 이루어져있다. 함수는 이러한 복잡한 프로그램의 흐름을 좀 더쉽게 풀어 나갈 수 있다.
2.코드의 재사용성 : 함수를 통해서 만들어 기능들을 만들어 놓으면 모든 프로그램 기능들은 분리된 모듈화된 기능들은 그 함수를 쓰기에 재사용이 될 수 있다.
3.코드의 안전성 : 함수 단위로 어떤 담당자가 지정되어서 개발을 하면 하나에만 집중하기에 코드의 안전성이 좋아진다.

파이썬 함수 사용법

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

함수 정의 방법 📕

• 인수(매개변수)가 들어가는 형태, parameter가 있는 함수도 있고 없는 함수도 있다.

# 아래가 기본 함수 정의 형태이다.
def function_name(parameter):  
    code

예1

# 함수를 만들때 파라미터는 임의로 지정
def first_func(w): # 함수 내부에서 쓸 변수를 w로 선언
    print('Hello, ', w) # 함수를 호출할때 w에 어떤 단어가 와서 마지막에 print문으로 출력
word = 'Good boy'
first_func(word)
>>> Hello,  Good boy

• first_func()은 하나의 인자를 필요로 하기에 아래와 같은 상황에서는 error가 발생한다.
• 우리가 만든 w 매개 변수를 필요로 하는데 존재하지 않기 때문이다.

def first_func(w): 
    print('Hello, ', w) 
word = 'Good boy'
first_func()
>>> TypeError: first_func() missing 1 required positional argument: 'w'

예2

• 리턴이 있는 함수는 내가 이 함수에서 넘어오는 결과값으로 반환되는 값을 받을 변수를 선언해야한다.
• 예1 하고 출력되는 것은 비슷하지만 전혀 다른 양상, 1번은 그냥 print문을 호출한 것이고 2번은 내가 원하는 값을 만들어서 반환받아서 호출한 것

  def return_func(w1):  
      value = 'Hello ' + str(w1)
      return value # value를 통해 리턴하고자 하는 값을 정의한다.
  x = return_func('Good boy!')
  print(x) 
  >>> Hello Good boy!  

예3(다중반환)

• 임의의 정수나 실수를 입력받아서 곱하기를 해서 3개를 동시에 리턴

def func_mul(x):       
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return y1, y2, y3
x, y, z= func_mul(10) # 3개를 리턴하기에, 받는쪽도 3개로 입력받아야한다.(언팩킹)
print(x, y, z)
>>> 100 200 300

튜플 리턴 📕

• 리턴값에 괄호만 묶었을 뿐인데 튜플로 리턴이되고, 여러 개의 원소를 하나로 묶어서 q로 보냈기에 팩킹됬다.

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_mul3(x):         
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return [y1,y2,y3]
p = func_mul3(20)
print(type(p), p, set(p)) 
>>> <class 'list'> [200, 400, 600] {200, 600, 400}

딕셔너리 리턴 📕

• 리턴값을 딕셔너리로 묶어주자.

def func_mul4(x):         
    y1 = x * 10
    y2 = x * 20
    y3 = x * 30
    return {'v1' : y1, 'v2': y2, 'v3': y3}
d = func_mul4(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'])

enumerate 📕

• enumerate는 순서와 값을 알려준다.
• enumerate() 함수를 사용하면 반복문에서 요소의 인덱스와 값을 쉽게 얻을 수 있습니다.

  names=['철수', '영희', '훈이']
  for i,name in enumerate(names):
      print('{}번째,{}'.format(i, name))
  >>> 
  0번째,철수
  1번째,영희
  2번째,훈이

*args, **kwargs 📕

• *args(언팩킹)
• 함수에 임의의 개수의 인자를 전달할 수 있게 해줍니다. "args"는 "arguments"의 약자이며, 함수에 전달된 인자들을 튜플로 묶어서 처리합니다.
• 매개변수 명은 자유, *args는 가변, 한개가 넘어올수도 있고, 여러개가 넘어 올수있다. 어떤 묶음이 넘어오더라도 횟수만큼 풀어서 사용가능

def args_func(*args):  
    for i,v in enumerate(args): # i는 index 0번부터 시작하고, v는 실제값
        print('Result : {}'.format(i), v)
    print('------') # (*args)에 어떤 묶음이 오더라도 횟수만큼 풀어서 사용한다는 의미
args_func('Lee') # *가 붙어있으면 튜플 형태의 0번 index로 인식한다.
>>> 
Result : 0 Lee
------
# 2개를 호출할 때 ,우리가 함수를 선언할 때 보통인자가 2개면, (*args, ars)이렇게 2개를 받아야하는데 언팩킹으로, 네가 넘기는 것들을 묶어서 보낸다고 나는 생각할 것이고,(*args)와서 나는 풀어서 하나의 자료구조로써 메소드 안에서 사용하게해준다는 뜻
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(언팩킹)
• 딕셔너리 자료형, 키와 벨류를 매개면수로 넘길때 사용
• 딕셔너리 언팩킹 자료형은 *를 2개 붙인다.

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 = 'City') 
>>> 
name1 : Lee
name2 : Park
name3 : City
------

전체 혼합 📕

• 10과 20은 *가 붙지않은 정확히 2개이기에 순서대로, args_1, args_2에 들어간다.
• 'Lee', 'Kim', 'Park'는 *args에 할당
• age1=20, age2=30, age3=40은 **kwargs에 할당
• 함수를 유연하게 인수의 갯수에 구애받지 않고 내가 원하는 어떤 형태로 폭 넓게 다양한 기능을 수행 할 수 있도록 만들수있께 해주는것이 *붙은 언팩킹이다.

def example(args_1, args_2, *args, **kwargs):
    print(args_1, args_2, args, kwargs)
example(10, 20, 'Lee', 'Kim', 'Park', age1 = 20, age2 = 30, age3 = 40)
>>> 0 20 ('Lee', 'Kim', 'Park') {'age1': 20, 'age2': 30, 'age3': 40}

중첩함수 📕

• 함수안에 함수가 있는 형태
• nested_func 함수를 호출하지 않고 func_in_func 를 사용할 수 없다. (정의가 안되어있기에)

def nested_func(num):
    def func_in_func(num): # 함수정의
        print(num)
    print('in func')
    func_in_func(num + 100)  # 함수 호출
func_in_func(1000)

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

람다(lambda) 📕

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

람다(lambda) 함수는 파이썬에서 간단한 함수를 간결하게 정의하는 방법입니다. 람다 함수는 lambda 키워드를 사용하여 정의하며, 주로 간단한 연산을 수행하는 함수를 작성할 때 활용됩니다. 람다 함수는 익명(이름이 없는) 함수로도 불립니다.

기본구조

lambda arguments: expression

아래 함수를 람다식으로 바꾸면 ??

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

• func_final(10, 20, mul_func_var)도 가능, 함수 안에서 함수를 인자로 받을 때는 람다식을 바로 써서 넘겨도 되고, 이미 변수에 할당에 놓은 일반적 함수를 넣어도 된다. 아니면 자주 쓰는 람다를 정의해 놓고 변수로 넘겨도 된다.

def func_final(x, y, func):
    print('>>>>>>',x * y * func(100, 100))  # 3번째 인자는 함수로 받아보자.
func_final(10, 20, lambda x,y: x*y) 
>>>>> 2000000

Hint 📕

• 파이썬 함수 힌트는 함수의 매개변수와 반환값의 데이터 타입을 명시적으로 지정하는 주석입니다. 이를 통해 코드의 가독성을 높이고, 코드를 사용하는 다른 개발자나 도구들이 함수를 더 쉽게 이해하고 활용할 수 있게 됩니다.

• 함수 힌트를 통해 word 매개변수의 데이터 타입은 문자열(str)이고, num 매개변수의 데이터 타입은 정수(int)이며, 함수의 반환값은 정수(int)임을 나타내고 있습니다.

• 함수는 입력받은 문자열의 길이와 정수를 곱한 값을 반환합니다. 여기서는 'I love you'라는 문자열의 길이(10)과 10이 주어졌으므로, 반환값은 100이 될 것입니다.

def tot_length(word: str, num: int) ->int:
    return len(word) * num
print('hint eam1 : ', tot_length('I love you', 10))
>>> hint eam1 :  100

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

지금까지 배운 것들을 함수안에서 사용해보고 여러가지 사측연산을 이용해서 계산기 형식으로 만들어보면 함수에 익숙해지고 좋을 것 같습니다.😙

출처 : 인프런