Gidhub BE Developer

반복문 작성 시 도움이 되는 함수

2018-02-01
goodGid

반복문 작성 시 도움이 되는 함수

Filter() 함수

  • 리스트 내장의 if문으로 필터링하는 방법과 동일한 기능을 하는 함수가 내장 함수인 filter()이다.

  • 함수는 입력받은 시퀀스형 객체, 즉 이터레이션이 가능한 객체를 순회하며, 함수의 결과가 Ture인 경우만을 묶어
    해당 이터레이터 객체를 반환한다.

filter( <function> | None, <이터레이션이 가능한 자료형>)
  • 첫 번째 인자는 은 함수의 이름으로 `필터링할 방법`을 제공한다.

  • 함수의 이름에 None을 지정하면 아무런 필터링도 수행하지 않는다.
    즉 시퀀스 객체의 모든 아이템을 선택하고 싶을 때는 ‘None’을 사용한다.

  • 두 번째 인자는 필터링할 대상으로, 리스트, 튜플, 문자열 형태의 시퀀스형 자료, 이터레이터를 지원하는 사용자정의 클래스, 이터레이터 객체가 올 수 있다.

  • filter() 내장 함수는 반환값으로 이터레이터를 반환하므로 리스트나 튜플에 담으려면 내장 함수인 list(), tuple()을 사용해야 한다.

>>> IterL = filter(None, L)
>>> for i in IterL:
...     print(" Itme : {0}" .format(i))
... 
 Itme : 10
 Itme : 25
 Itme : 30
  • 필터링 함수를 지정해 필터링 하는 예제
>>> L = [10, 25, 30]
>>> IterL = filter(GetBiggerThan20,L)
>>> for i in IterL:
...     print("Item : {0}" .format(i))

Item : 25
Item : 30
  • 필터링 결과로 이터레이터 객체를 사용하지 않고 원본 객체와 동일한 리스트, 튜플, 사전 형식으로 사용하기 위해선 list(), tuple(), dict() 함수를 사용한다.

  • 이때 기존 객체인 L은 아무것도 바뀌지 않는다.

>>> NewL = list(filter(GetBiggerThan20,L))
>>> NewL
[25, 30]
>>> L
[10, 25, 30]
  • def Function 정의를 하지 않고 람다(Lambda) 함수를 이용해 작성할 수 있다.
>>> IterL = filter(lambda i : i > 20, L)
>>> for i in IterL:
...     print("Item : {0}" .format(i))

Item : 25
Item : 30

Zip() 함수

  • zip()함수는 순회 가능한 시퀀스형이나 이터레이터형 객체들을 결합하여 쌍으로 순회가능한 이터레이터 객체를 얻을 수 있다.

  • zip()함수의 인자로는 내장 시퀀스형 자료, 이터레이터를 지원하는 사용자 클래스, 이터레이터 객체가 가능하며, 결합을 시키고자 하는 개수만큼 올 수 있다.

  • 반환 값은 쌍을 이룬 튜플 객체이터레이터형이다.

>>> X = [10,20,30]
>>> Y = ['A','B','C']
>>> for i in zip(X,Y):
...     print("Item : {0}" .format(i))

Item : (10, 'A')
Item : (20, 'B')
Item : (30, 'C')
>>> 

  • zip()함수는 이터레이터를 반환하므로 결과 값을 객체에 저장하려면 filter()와 동일하게 내장 함수인 list(), tuple(), dict()등을 이용해야 한다.
>>> RetList = list(zip(X,Y))
>>> RetList
[(10, 'A'), (20, 'B'), (30, 'C')]
  • zip()함수로 결합된 결과를 분리하기 위해 zip()을 호출할 때 결합된 객체나 이터레이터인자 앞에 *붙여 분리할 수 있다.
>>> X2, Y2 = zip(*RetList)
>>> X2
(10, 20, 30)
>>> Y2
('A', 'B', 'C')
  • zip()함수를 이용해 2개 이상의 객체도 결합할 수 있다.

  • 결합을 하는 인자의 개수가 동일하지 않은 경우 가장 짧은 쪽을 기준으로 결합된다. 나머지 시퀀스 객체는 포함되지 않는다.

>>> X = [10,20,30]
>>> Y = "ABC"
>>> Z = (1.5, 2.5, 3.5)
>>> RetList = list(zip(X,Y,Z))
>>> RetList
[(10, 'A', 1.5), (20, 'B', 2.5), (30, 'C', 3.5)]

Map() 함수

map( <함수 이름>, 이터레이션 가능한 객체, ...)
  • 첫 인자로 ‘함수의 이름’이 온다. 뒤에 오는 인자는 순회 가능한 객체로 filter(), zip()과 동일하다.

  • map() 함수는 객체를 순회하며
    각 아이템을 첫 인자인 함수에 전달하고,
    함수의 수행 결과를 이터레이터 객체로 생성해서 반환한다.

>>> L = [1,2,3]
>>> def Add10(i):
...     return i+10


>>> for i in map(Add10, L):       # 정의한 함수와 순회할 객체를 map()인자로 전달한다.
...     print("Item : {0}" .format(i))

Item : 11
Item : 12
Item : 13
  • 수행할 함수가 간단하다면 람다(Lambda) 함수로 작성할 수 있다.
    >>> RetList = list(map((lambda i : i+10), L))
    >>> RetList
    [11, 12, 13]
    
  • 수행할 함수가 2개 이상의 인자를 받는 경우, map()함수를 호출할 때도 수행할 함수에 맞는 이터레이션 가능한 객체를 전달해야 한다.
>>> X = [1,2,3]
>>> Y = [2,3,4]
>>> RetList = list(map(pow,X,Y))
>>> RetList
[1, 8, 81]

효울적인 순회 방법

  • 파이썬에서 시퀀스형 자료를 순회하며 출력하는 방법은 여러 가지가 있다.
>>> l = ["Apple", "Orange", "Banana"]
>>> for i in l:         # for문 이용
...     print(i)

Apple
Orange
Banana

>>> print("\n".join(l))       # join 메서드를 이용하는 경우
Apple
Orange
Banana

>>> print("\n" .join(i for i in l))           # 리스트 내장을 이용하는 경우
Apple
Orange
Banana
  • 위의 결과는 같지만 수행 속도는 차이가 있다.

  • for문을 이용해 출력하는 경우에는 리스트의 아이템 개수만큼 print() 함수를 호출한다.

  • join()이나 리스트 내장을 이용하는 경우에는 print()함수가 한 번만 호출된다.


Comments

Content