devbamtol 님의 블로그

Python의 itertools 라이브러리는 효율적인 반복을 위한 다양한 함수를 제공하는 강력한 도구입니다. 

[요약]

1. count(start = 0, step = 1)
start 부터 step 만큼 무한히 증가하는 숫자 생성

2. cycle(iterable)
요소를 무한히 순환하면서 생성

3. repeat(object[, times])
object를 times 만큼 반복하거나, times 가 생략되면 무한히 반복

4. permutations(iterable, r=None)
iterable 에서 r 개의 요소를 뽑아 나열하는 모든 순열을 생성순서가 다르면 다른 결과로 취급

5. combinations(iterable, r)
iterable 에서 r 개의 요소를 뽑아 만들 수 있는 모든 조합을 생성순서는 고려하지 않음 -> 순서가 같으면 같은 거

6. product(*iterables, repeat=1)
여러 개의 iterable들 간의 데카르트 곱을 구한다

7. chain(*iterables)
여러 개의 iterable을 하나로 연결하여 새로운 iterable 한 요소를 생성8. islice(iterable, start, stop[, step])이터레이터 버전 슬라이싱

무한 이터레이터 (Infinite Iterators)

이 함수들은 무한한 시퀀스를 생성합니다. 따라서 사용할 때에는 반드시 종료 조건을 함께 사용해야 합니다.

1. itertools.count(start=0, step=1)

count()는 start 값부터 step 만큼씩 무한히 증가하는 숫자를 생성합니다.

예시: 10부터 2씩 증가하는 숫자 5개를 출력합니다.

import itertools

# 10에서 시작하여 2씩 증가하는 이터레이터 생성
counter = itertools.count(start=10, step=2)

# 5개의 숫자 출력
for _ in range(5):
    print(next(counter))

출력:

10
12
14
16
18

2. itertools.cycle(iterable)

cycle()은 인자로 받은 반복 가능한(iterable) 객체의 요소들을 무한히 순환하면서 생성합니다.

예시: 신호등의 색깔을 계속해서 순환 출력합니다.

import itertools
import time

traffic_light = itertools.cycle(['🔴', '🟡', '🟢'])

for _ in range(6):
    print(next(traffic_light))
    time.sleep(1) # 1초 대기

출력:

🔴
🟡
🟢
🔴
🟡
🟢

3. itertools.repeat(object[, times])

repeat()는 object를 times 만큼 반복하거나, times가 생략되면 무한히 반복합니다.

예시: 'Hello'를 3번 반복하여 리스트를 생성합니다.

import itertools

repeater = itertools.repeat('Hello', times=3)

print(list(repeater))

출력:

['Hello', 'Hello', 'Hello']

 조합 이터레이터 (Combinatoric Iterators)

이 함수들은 입력받은 데이터로부터 순열, 조합 등과 같은 조합적 시퀀스를 생성합니다.

 4. itertools.permutations(iterable, r=None)

permutations()는 iterable에서 r개의 요소를 뽑아 나열하는 모든 순열을 생성합니다. 순서가 다르면 다른 경우로 취급합니다. r을 생략하면 iterable의 전체 길이로 설정됩니다.

예시: 리스트 [1, 2, 3]에서 2개의 요소를 뽑아 만들 수 있는 모든 순열을 구합니다.

import itertools

items = [1, 2, 3]
p = itertools.permutations(items, 2)

print(list(p))

출력: (1, 2)와 (2, 1)은 다른 순서이므로 모두 포함됩니다.

[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

 5. itertools.combinations(iterable, r)

combinations()는 iterable에서 r개의 요소를 뽑는 모든 조합을 생성합니다. 순서는 고려하지 않습니다.

예시: 리스트 [1, 2, 3, 4]에서 2개의 요소를 뽑아 만들 수 있는 모든 조합을 구합니다.

import itertools

items = [1, 2, 3, 4]
c = itertools.combinations(items, 2)

print(list(c))

출력: (1, 2)와 (2, 1)은 같은 조합이므로 (1, 2)만 포함됩니다.

[(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

 6. itertools.product(*iterables, repeat=1)

product()는 여러 개의 iterable들 간의 **데카르트 곱(Cartesian product)**을 구합니다. 중첩된 for문과 동일한 결과를 반환합니다.

예시: 두 리스트 ['a', 'b']와 [1, 2]의 데카르트 곱을 구합니다.

import itertools

list1 = ['a', 'b']
list2 = [1, 2]

prod = itertools.product(list1, list2)

print(list(prod))

출력:

[('a', 1), ('a', 2), ('b', 1), ('b', 2)]

 기타 유용한 이터레이터

 7. itertools.chain(*iterables)

chain()은 여러 개의 iterable을 하나로 연결하여 새로운 이터레이터를 생성합니다.

예시: 두 개의 리스트와 하나의 튜플을 연결합니다.

import itertools

list1 = [1, 2, 3]
list2 = ['a', 'b']
tuple1 = ('X', 'Y')

chained_iter = itertools.chain(list1, list2, tuple1)

print(list(chained_iter))

출력:

[1, 2, 3, 'a', 'b', 'X', 'Y']

 8. itertools.islice(iterable, start, stop[, step])

islice()는 이터레이터 버전의 슬라이싱입니다. start, stop, step 인자를 사용하여 이터레이터의 일부를 잘라낼 수 있습니다.

예시: range(10) 이터레이터에서 인덱스 2부터 8까지 2씩 건너뛰며 값을 가져옵니다.

import itertools

sliced_iter = itertools.islice(range(10), 2, 8, 2)

print(list(sliced_iter))

출력:

[2, 4, 6]

[수치 연산 함수]

1. abs()

인자로 숫자를 전달하면 그 숫자의 절대값을 반환

val = 10
print(abs(val))

>> 10

2. divmod()

첫 번째 인자를 두 번째 인자로 나눴을 때의 몫과 나머지를 튜플 객체로 반환

print(divmod(9, 5))

>> (1, 4)   # 몫, 나머지

3. pow()

첫 번째로 전달된 인자 값에 대해 두 번째로 전달된 인자 값으로 제곱한 결과를 반

data_list = [1, 2, 3, 4, 5]
print( list( map( lambda x: pow(x, 2), data_list)))

>> [1, 4, 9, 16, 25]

[시퀀스형/반복 가능한 자료형을 다루는 함수]

4. all()

반복 가능한 자료형인 List, Tuple, Set, dictionary, 문자열 등을 인자로 전달하여 항목 모두가 True 이면 True, False가 하나라도 있으면 False

print( all( ['A', 'B', ""] ))

>> False

5. any()

반복 가능한 자료형인 List, Tuple, Set, dictionary, 문자열 등을 인자로 전달하여 항목 모두가 False 이면 False, True가 하나라도 있으면 True

print( all( ['A', 'B', ""] ))

>> True

6. enumerate()

List, Tuple, 문자열과 같은 시퀀스형을 입력받아 인덱스를 포함하는 튜플 객체를 항목으로 구성하는
enumerate 객체를 반환

data_list = [10, 20, 30, 40, 50]

for obj in enumerate(data_list):
    print("{0}: {1}, {2}".format(type(obj), *obj))     #변수 obj: 인덱스와 값을 가진 튜플 객체를 {1}, {2}에 순서대로 대입

>> <class 'tuple'>: 0, 10
      <class 'tuple'>: 1, 20
      <class 'tuple'>: 2, 30
      <class 'tuple'>: 3, 40
      <class 'tuple'>: 4, 50

7. filter()

조건에 해당하는 항목을 걸러내는 함수   filter(조건, 리스트)

def iseven(num):
    return num % 2 == 0

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

ret_val = filter(iseven, numbers)
 # ret_val = filter( lambda n: n%2 == 0, numbers)

print(type(ret_val))
print(list(ret_val))

>> <class 'filter'>
     [2, 4, 6, 8, 10]

8. list(), tuple(), set(), dict()

반복 가능한 자료형을 인자로 전달 받아, 각각 리스트, 튜플, 셋, 딕셔너리로 변환해 반환

data_str = "Hello"

print(list(data_str))
>> ['H', 'e', 'l', 'l', 'o']

print(tuple(data_str))
>> ('H', 'e', 'l', 'l', 'o')

print(set(data_str))
>> {'H', 'e', 'l', 'o'}

print(dict(enumerate(data_str)))
>> {0: 'H', 1: 'e', 2: 'l', 3: 'l', 4: 'o'}

9. map()

두 번째 인자로 반복 가능한 자료형을 전달 받아 자료형의 각 항목에 대해 첫 번째 인자로 전달 받은 함수를 적용한 결과를
맵 객체로 반환

[1]
data_list = list("abcdef")
result = list(map(lambda x: x.upper(), data_list))

print(result)

>> ['A', 'B', 'C', 'D', 'E', 'F']

[2]
var1, var2, var3 = map( int, input().split())
print(var1, var2, var3)

>> 1 2 3
     1 2 3

10. max(), min()

반복 가능한 자료형을 인자로 전달받아 각각 항목 중 가장 큰 값, 작은 값 반환

data_list = list({10, 25, 30, 45, 50})

print("{0} => min: {1}, max: {2}".format(data_list,min(data_list),max(data_list)))

>> [10, 25, 30, 45, 50] => min: 10, max: 50

11. range()

(시작 값, 종료 값, 증감치)를 전달하여 시퀀스형 객체를 생성

data_list1 = list(range(0, 10, 1))
data_list2 = list(range(0, 10))
data_list3 = list(range(10))

print(data_list1)
print(data_list1)
print(data_list1)

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

12. sorted()

반복 가능한 자료형을 인자로 전달받아 항목들로부터 정렬된 리스트를 생성해 반환

data_list = [3, 8, 12, 2, 5, 11]
asc_result = sorted(data_list)
desc_result = list(reversed(asc_result))

print(asc_result)
print(desc_result)

>>  [2, 3, 5, 8, 11, 12]
      [12, 11, 8, 5, 3, 2]

13. zip()

둘 이상의 반복 가능한 자료형을 인자로 전달받아, 동일 위치의 항목을 묶어 튜플을 항목으로 구성하는 zip 객체를 생성
 * 인자로 전달된 객체는 동일 자료형이면서, 항목의 개수가 같아야 함 

data_list1 = [1, 2, 3]
data_list2 = [4, 5, 6]
data_list3 = ["a", "b", "c"]


print(zip(data_list1, data_list2))
print(list(zip(data_list1, data_list2)))
>> <zip object at 0x0000027A80E91300>
      [(1, 4), (2, 5), (3, 6)]

print(list(zip(data_list1, data_list2, data_list3)))
>> [(1, 4, 'a'), (2, 5, 'b'), (3, 6, 'c')]

print(dict(zip(data_list3, data_list1)))
>> {'a': 1, 'b': 2, 'c': 3}

[변환 함수]

14. chr(), ord(), hex()

정수 형태의 유니코드 값을 인자로 전달받아 해당 코드의 문자를 반환
문자를 인자로 전달받아 유니코드 값(10진 정수)을 반환
10진 정수 값을 인자로 전달받아 16진수로 변환된 값을 반환

print(chr(65))
>> A
print(ord('a'))
>> 97
print(ord('가'))
>> 44032
print(hex(ord('가')))
>> 0xac00

15. int(), float(), str()

인자로 전달된 숫자 형식의 문자열, 부동소수점 숫자를 정수로 변환
인자로 전달된 숫자 형식의 문자열, 정수를 부동소수점 숫자로 변환
인자로 전달된 객체에 대한 문자열 변환 값을 반환

x = "10" #문자열 10
y = "3C"
z = 4.5

print(int(x,  2))
>> 2   #2진수 10을 10진수 2로 변환 후 반환
print(int(y, 16))
>> 60  #16진수 3C를 10진수 60으로 반환
print(int(z))
>> 4   #버림

[객체 조사를 위한 함수]

16. dir()

인자로 전달된 객체가 가지고 있는 변수, 메서드와 같은 속성 정보를 리스트 객체로 반환
인자를 전달하지 않고 호출하면 현재 지역 스코프에 대한 정보를 리스트 객체로 반환

print(dir())      #지역 스코프에 대한 정보를 리스트 객체로 반환
>> ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']

data_str = "Hello, Python!"
print( dir(data_str))     #문자열이 가지고 있는 많은 메소드 정보를 리스트 객체에 담아 반환
>> ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

data_list = [10, 20, 30, 40, 50]
print( dir(data_list))      #정수형 리스트 객체가 가지고 있는 메소드 정보들을 리스트 객체에 담아 반환
>> ['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

data_dict = {"key1" : 10, "key2" : 20, "key3" : 30}
print( dir(data_dict))      #객체가 가지고 있는 메소드 정보들을 리스트 객체에 담아 반환
>> ['__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__ior__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__ror__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

17. globals(), locals()

현재의 전역 심볼 테이블을 보여주는 딕셔너리를 반환
전역변수와 함수, 클래스의 정보 포함

현재의 지역 심볼 테이블을 보여주는 딕셔너리를 반환
매개변수를 포함한 지역변수와 중첩함수의 정보 포함

class MyClass:
      pass

def test_fn(param):
      def inner_fn():
              pass
      val1 = 5
      val2 = 8
      for item in locals().items():
            print(item[0], item[1])

value1 = 10
value2 = 20
obj1 = MyClass()

g = dict(globals())

print("globals()")
for item in g.items():
      print(item[0], item[1])

print("\n\nlocals()")
test_fn(10)


>>
globals()
__name__ __main__ __doc__ None __package__ None __loader__ <_frozen_importlib_external.SourceFileLoader object at 0x00000173B265BF20> __spec__ None __annotations__ {} __builtins__ <module 'builtins' (built-in)> __file__ c:\python\Quiz\s250715.py __cached__ None
MyClass <class '__main__.MyClass'> test_fn <function test_fn at 0x00000173B261CA40> value1 10 value2 20 obj1 <__main__.MyClass object at 0x00000173B285A660>

locals()
param 10 inner_fn <function test_fn.<locals>.inner_fn at 0x00000173B287D080> val1 5 val2 8

18. id()

인자로 전달된 객체의 고유 주소(참조값)를 반환

x = 10
print(hex(id(x)))
 >> 0x7ffc31fa4ad8

y = 10
print(hex(id(y)))
>> 0x7ffc31fa4ad8

z = "10"
print(hex(id(z)))
>> 0x1d6f9b89b00

19. isinstance(), issubclass()

첫 번째 인자로 전달된 객체가 두 번째 인자로 전달된 클래스의 인스턴스인지에 대한 여부를 T/F로 반환

첫 번째 인자로 전달된 클래스가 두 번째 인자로 전달된 클래스의 서브클래스인지에 대한 여부를 T/F로 반환

class Parent:
    pass

class Child(Parent):
    pass

p= Parent()
c = Child()

print(isinstance(p, Parent))
>>  True

print(isinstance(c, Child))
>> True

print(isinstance(c, Parent))
>>True
 
print(isinstance(p, Child))
>> False

print(issubclass(Child, Parent))
>> True

[실행 관련 함수]

20. eval()

표현 가능한 표현식의 문자열을 인자로 전달받아 해당 문자열의 표현식을 실행한 결과값을 반환

expr = "2 + 5 * 3"
expr2 = " 'hello, python!'.upper() "

print(eval(expr))
print(eval(expr2))

>>  17
       HELLO, PYTHON!