[Python] 함수 고급 (튜플,map,filter,lambda)

---

튜플

 

우리는 이미 파이썬을 공부하면서 튜플 형태의 자료형을 공부했는데,

 

튜플만이 가지는 특이한 성질이 밑바탕이 되어 함수에서도 많이 사용되곤 한다.

 

튜플의 특징

• 기본적인 사용법은 리스트와 동일
• 단, 한 번 지정한 자료의 변동은 불가하다.
• 만약 변수에 새로운 요소를 추가하고 싶다면 변수를 다시 생성해야 한다.
• 튜플을 생성할 때 변수와 값이 수 일치된다면 소괄호를 생략할 수 있다.

여기서 주목해야 할 건 값의 변동이 불가능하다는 점과 새로운 요소를 추가하기 위해서는 변수를 재생성해야 한다는 점이다.

 

a,b = (10, 20)
print(a)
print(b)

ti = b,a = 10, 20
print(a)
print(b)
print(type(ti))

10
20
20
10
<class 'tuple'>

 

이처럼 값의 수정이 아닌 변수 위치 변화만으로 출력 값이 달라지는 것을 확인할 수 있고,

 

소괄호를 제거하고 출력을 하게 되더라도 튜플 타입을 유지하고 있다.

 

 

# 혼자공부하는파이썬 발췌

def test():
  return(10,20)
  
a,b = test()

print('a:',a)
print('b:',b)
a: 10
b: 20

 

함수에서 튜플은 리턴 값에 많이 사용된다. 함수의 리턴에 튜플을 사용하면 여러 개의 값을 리턴하고 할당할 수 있기 때문이다.

 

 

# 혼자공부하는파이썬 발췌

for i, value in enumerate([1, 2, 3, 4, 5, 6]):
  print("{}번째 요소는 {}입니다.".format(i, value))

0번째 요소는 1입니다.
1번째 요소는 2입니다.
2번째 요소는 3입니다.
3번째 요소는 4입니다.
4번째 요소는 5입니다.
5번째 요소는 6입니다.

 

위의 for문에서 사용된 i, value도 소괄호를 생략한 튜플의 예이다.

 

---

Map

 

맵 함수의 기본 형태는 map(함수, 리스트)로 사용된다.

 

예시를 보기 전에 간단하게 설명하자면 리스트를 함수에 집어넣어 여러 가지 처리를 통해 리턴된 값을

 

새로운 리스트로 구성해주는 역할을 한다.

 

 

# 혼자공부하는파이썬 발췌

def power(item):
  return item * item

list_input_a = [1,2,3,4,5]

output_a = map(power, list_input_a)
print("# map()함수의 실행결과")
print("map(powerm list_input_a):", output_a)
print("map(powerm list_input_a):", list(output_a))
print()

# map()함수의 실행결과
map(powerm list_input_a): <map object at 0x7fb23b4c3c50>
map(powerm list_input_a): [1, 4, 9, 16, 25]

 

power() 함수를 살펴보면 매개변수를 제곱해주는 함수로 매개변수를 일반적으로 입력하지 않고,

 

map 함수를 활용하여 만들어둔 리스트를 매개로 값을 반환했다.

 

이런 함수는 상황에 따라 코드를 줄여주기 때문에 눈도장을 꾹 찍어두자

 

---

Filter

 

필터 함수는 이름 그대로 리스트를 함수에 넣고 특정 조건에 요소 값이 True인 것으로만 뽑아 새로운 리스트를 구성해준다.

 

기본적인 형식은 filter(함수, 리스트) 형태이다. 

 

# 혼자공부하는파이썬 발췌

def under_3(item):
  return item < 3

list_input_a = [1,2,3,4,5]

output_b = filter(under_3, list_input_a)
print("# filter()함수의 실행결과")
print("filter(under_3, list_input_a):", output_b)
print("filter(under_3, list_input_a):", list(output_b))
print()

# filter()함수의 실행결과
filter(under_3, list_input_a): <filter object at 0x7fb23b4c36d0>
filter(under_3, list_input_a): [1, 2]

under_3() 함수는 3보다 작은 값들을 반환하는 함수이고, list_input_a는 1부터 5까지의 요소를 가지고 있는 리스트이다.

 

filter(under_3, list_input_a)로 함수를 구성하여 실행하면,

 

1부터 5까지로 구성된 list_input_a에서 3 미만인 요소 1, 2만 반환된 것을 확인할 수 있다.

 

추가로 출력된 <map object>와 <filter object>는 제너레이터로 추후에 다시 살펴보도록 하자.

 

---

lambda

 

람다를 사용하게 되면 길고 거추장스러운 코드를 압축하여 보다 간결하게 코드를 구성할 수 있고,

 

이는 곧 가독성으로 이어지기 때문에 많은 개발자들이 사용하는 방식이다.

 

람다의 기본 형태는 lambda 매개변수:리턴 값으로 사용된다.

 

# 혼자공부하는파이썬 발췌
# 람다 기본틀

power = lambda x: x *x

list_input_aa = [1,2,3,4,5]

output_a = map(power, list_input_a)

print("#map() 함수의 실행결과")
print("map(power, list_input_a):", output_a)
print("map(power, list_input_a):", list(output_a))


#map() 함수의 실행결과
map(power, list_input_a): <map object at 0x7fb23b4fe650>
map(power, list_input_a): [1, 4, 9, 16, 25]​

 

이를 보다 더 간결하게 축약하여 람다를 함수의 매개변수에 곧바로 넣을 수 있는데 이를 '인라인 람다'라고 한다.

 

# 인라인람다

list_input_a = [1,2,3,4,5]

output_a = map(lambda x: x*x, list_input_a)
print("#map()함수의 실행결과")
print("map(power, list_input_a):", output_a)
print("map(power, list_input_a):", list(output_a))

#map()함수의 실행결과
map(power, list_input_a): <map object at 0x7fb23b49fa10>
map(power, list_input_a): [1, 4, 9, 16, 25]

 

변수 output_a에 정의한 함수를 요소로 넣고 map(lambda '여러 가지 처리', 참조할 변수) 단 한 줄로 

 

코드를 구성하여 반환값을 얻은걸 확인할 수 있다.

 

list_input_a = [1,2,3,4,5]
under_3 = lambda x: x < 3

output_b = filter(under_3, list_input_a)

print("filter(under_3, list_input_b):", list(output_b))

filter(under_3, list_input_b): [1, 2]

========================================================

list_input_a = [1,2,3,4,5]

output_b = filter(lambda x: x<3, list_input_a)

print("filter(under_3, list_input_a):", list(output_b))

filter(under_3, list_input_a): [1, 2]

 

이처럼 코드를 간결하게 작성할 수 있는 테크닉은 실전에서 매우 중요하게 여겨지니 잘 활용하도록 하자.

 

추가로 람다는 매개변수가 여러 개인 람다도 만들 수 있다.

 

lambda x, y : x * y

 

 

---

함수 데코레이터

 

 

함수 데코레이터란 쉽게 말해 함수를 편리하게 사용할 수 있는 툴이다.

 

미리 지정된 함수를 반환 값만 바꾸어 출력한다거나, 코드를 좀 더 간결하게 만들기 위해 주로 사용되고

 

데코레이터를 사용하면 functools라는 모듈의 사용을 할 수 있어 유용하게 사용할 수 있다.

 

 

def test(function): #2 test() 함수 실행
  def wrapper():
    
    print('인사가 시작되었습니다.') #4 print()함수 실행
    
    function() #5 hello()함수 실행
    
    print('인사가 종료되었습니다.') #7 print()함수 실행, 실행 종료
  
  return wrapper #3 wrapper 함수 실행

@test #1 test의 매개변수 function에 hello()함수가 들어간다.

def hello():
  print('hello') #6 hello()함수 내부 print('hello') 출력

@test
def bye():
  print('bye')

@test
def hi():
  print('hi')

hello()  
print()
bye()
print()
hi()

인사가 시작되었습니다.
hello
인사가 종료되었습니다.

인사가 시작되었습니다.
bye
인사가 종료되었습니다.

인사가 시작되었습니다.
hi
인사가 종료되었습니다.

 

 

함수의 구조가 조금 복잡하니 함께 살펴보자 먼저 @(데코레이터)'함수'를 통해 반복될 함수의 매개변수에 들어갈

 

함수를 지정한다. 위의 예시에서 test() 함수가 실행되면 test()함수의 리턴 값이 반환되어

 

wrapper() 함수가 실행되어 첫번재 출력 값이 '인사가 시작되었습니다.'가 출력된다.

 

이후 test()함수의 매개변수 function이 실행되어 데코레이터로 지정된 hello( ) 함수가 실행되기 때문에

 

두 번째로 hello가 출력된 후 wrapper의 마지막 줄 '인사가 종료되었습니다.'가 출력되며 프로그램이 종료된다.

 

한 번 데코레이터를 만들고 나면 몇 번이든 @데코를 통해 같은 함수를 손쉽게 사용할 수 있다.

 

 

 

 

 

 

 

 

 

 

---