제어문과 연관된 유용한 함수

range() - 수열의 생성

range(['시작값'], '종료값'[,  '증가값'])

'종료값'은 필수 항목

'시작값'과 '증가값'은 선택적으로 입력

기본적으로 '시작값'은 0, '증가값'은 1

>>> list(range(10))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> list(range(5, 10))

[5, 6, 7, 8, 9]

>>> list(range(10, 0, -1))

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

>>> list(range(10,20,2))

[10, 12, 14, 16, 18]

리스트 항목과 인덱스 값을 동시에 얻는 법

기존 방법

>>> L = ['Apple', 'Orange', 'Banana']

>>> for i in range(len(L)):

print("Index: {0}, Value: {1}".format(i, L[i]))

Index: 0, Value: Apple

Index: 1, Value: Orange

Index: 2, Value: Banana

enumerate 

enumerate('시퀀스 타입 객체'[, '시작값' = 0])

시퀀스 타입 객체 - 이터레이션이 가능한 객체가 입력

시작값 - 인덱스 순번의 시작값(생략 가능)

튜플 형태로 반환

시작값을 지정하지 않은 경우

>>> L = [100, 15.5, "Apple"]

>>> for i in enumerate(L):

print(i)

(0, 100)

(1, 15.5)

(2, 'Apple')

시작값을 지정한 경우

>>> L = [100, 15.5, "Apple"]

>>> for i, v in enumerate(L, 101):

print(i, v)

101 100

102 15.5

103 Apple

리스트 내장

기존의 리스트 객체를 이용해 조합, 필터링 등의 추가적인 연산을 통해 새로운 리스트 객체를 생성하는 경우 매우 효율적

<표현식> for <아이템> in <시퀀스 타입 객체> (if <조건식>)

<시퀀스 타입 객체> - 리스트, 튜플, 셋이나 이터레이션이 가능한 객체가 들어감

<아이템> - 리스트 객체의 개별 아이템

<표현식> - 개별 아이템을 사용해 맵핑 형태로 새로운 리스트 객체를 생성

if <조건식>은 조건식에 맞는 원본 리스트이 아이템을 선별하는데 사용

리스트, 튜플, 사전, range() 함수에 대해 리스트 내장을 이용한 리스트 객체 생성 예제

>>> l = [1, 2, 3, 4, 5]

>>> [i ** 2 for i in l]

[1, 4, 9, 16, 25]

>>> t = ("apple", "banana", "orange")

>>> (len(i) for i in t)

<generator object <genexpr> at 0x103f84140>

>>> [len(i) for i in t]

[5, 6, 6]

>>> d = {100:"apple", 200:"banana", 300:"orange"}

>>> [v.upper() for v in d.values()]

['BANANA', 'ORANGE', 'APPLE']

>>> [i ** 3 for i in range(5)]

[0, 1, 8, 27, 64]

if<조건식>을 이용

>>> l = ["apple", "banana", "orange", "kiwi"]

>>> [i for i in l if len(i) > 5]

['banana', 'orange']

리스트가 2개 이상의 다수인 경우에도 리스트 내장을 이용해 리스트의 조합을 만들어 수 있음

>>> L_1 = [3, 4, 5]

>>> L_2 = [1.5, -0.5, 4]

>>> [x * y for x in L_1 for y in L_2]

[4.5, -1.5, 12, 6.0, -2.0, 16, 7.5, -2.5, 20]

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

리스트 내장의 if 문으로 필터링하는 방법과 동일한 기능

이터레이션이 가능한 객체를 순회하며 함수의 결과가 True인 경우만을 묶어 이터레이터 객체를 반환

filter(<function> | None, <이터레이션이 가능한 자료형>)

첫번째 인자 - <function>은 함수의 이름으로 필터링할 방법을 제공

함수의 이름에 None을 지정하면 아무런 필터링도 안 함(시퀀스 객체의 모든 아이템 선택)

두번째 인자 - 필터링할 대상(리스트, 튜플, 문자열 형태의 시퀀스형 자료, 이터레이터를 지원하는 사용자의 클래스, 이터레이터 객체)

filter() 내장 함수의 반환값은 이터레이터, 리스트나 튜플에 담을 경우 내장함수 list(), tuple() 사용

필터링 함수 대신 None으로 지정

>>> L = [10, 25, 30]

>>> for i in IterL:

print("Item: {0}".format(i))

Item: 10

Item: 25

Item: 30

필터링 함수를 지정

>>> L = [10, 25, 30]

>>> def GetBiggerThan20(i):

return i > 20

>>> L = [10, 25, 30]

>>> IterL = filter(GetBiggerThan20, L)

>>> for i in IterL:

print("Item: {0}".format(i))

Item: 25

Item: 30

필터링 결과로 이터레이터를 사용하지 않고 리스트, 튜플, 사전 형식으로 사용

>>> L = [10, 25, 30]

>>> NewL = list(filter(GetBiggerThan20, L))

>>> NewL

[25, 30]

>>> L

[10, 25, 30]

lambda함수를 이용해 작성

>>> IterL = filter(lambda i: i > 20, L)

>>> for i in IterL:

print("Item: {0}".format(i))

Item: 25

Item: 30

zip() 함수

3개 이상의 시퀀스형이나 이터레이터형 객체를 튜플 형태로 서로 쌍을 묶을 수 있다.

인자는 내장 시퀀스 자료, 이터레이터를 지원하는 클래스, 이터레이터 객체

반환값은 쌍을 이룬 튜플 객체의 이터레이터형

>>> X = [10, 20, 30]

>>> for i in zip(X, Y):

print("Item: {0}".format(i))

Item: (10, 'A')

Item: (20, 'B')

Item: (30, 'C')

zip()함수느 이터레이터를 반환하므로 내장함수 list(), tuple(), dict() 이용

>>> X = [10, 20, 30]

>>> Y = ['A', 'B', 'C']

>>> 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')

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)]

결합을 하는 인자의 개수가 동일하지 않은 경우 가장 짧은 쪽을 기준으로 결합

>>> X = [10, 20, 30]

>>> Y = "ABCDE"

>>> RetList = list(zip(X, Y))

>>> RetList

[(10, 'A'), (20, 'B'), (30, 'C')]

map() 함수

시퀀스형 객체를 순회하면서 모든 값을 갱신할 때

map(<함수 이름>, 이터레이션이 가능한 객체, ...)

>>> L = [1, 2, 3]

>>> def Add10(i):

return i + 10

>>> for i in map(Add10, L):

print("Item: {0}".format(i))

Item: 11

Item: 12

Item: 13

람다 함수로 작성

>>> RetList = list(map((lambda i: i + 10), L))

>>> RetList

[11, 12, 13]

수행할 함수가 2개 이상의 인자를 받는 경우, 

map() 함수를 호출할 때도 수행할 함수에 맞는 이터레이션 가능한 객체를 전달

>>> RetList = list(map(pow, X, Y))

>>> RetList

[1, 8, 81]

효율적인 순회 방법

기본적인 for문을 이용하는 방법

>>> l = ['Apple', 'Orange', 'Banana']

>>> for i in l:

print(i)

Apple

Orange

Banana

join()이나 리스트 내자을 이용

>>> print("\n".join(l))

Apple

Orange

Banana

>>> print("\n".join(i for i in l))

Apple

Orange

Banana

두 방법은 결과는 같지만 수행 속도 면에서 미묘한 차이가 있음

for문을 이용 시 리스트의 아이템 개수만큼 print()함수를 호출

join()이나 리스트 내장을 이용 시 print() 함수가 단 한 번만 호출