๋ฐ์ํ
1. Itertools
- ํ์ด์ฌ์์ ์ ๊ณตํ๋ ์์ ๋ง์ ๋ฐ๋ณต์๋ฅผ ์์ฑํด์ฃผ๋ ํจ์์ด๋ค.
- ํน์ ๋ฐฐ์ด์ด๋ ์์ด์ ๋ํ ์กฐํฉ์ ๋ง๋ค์ด์ ์ด๋ฅผ ์ด์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋๋ค.
- ํจ์จ์ ์ธ ๋ฐ๋ณต์๋ฅผ ๊ตฌํ ์ ์๋ค.
- ๋ฌดํ ์ดํฐ๋ ์ดํฐ / ์กฐํฉํ ์ดํฐ๋ ์ดํฐ / ์ข ๋ฃ ์ดํฐ๋ ์ดํฐ ๊ฐ ์์ง๋ง, ์ข ๋ฃ ์ดํฐ๋ ์ดํฐ๋ ๋๋ฌด ๋ง์ผ๋ ์๋ ๋งํฌ๋ก ์ฒจ๋ถํด๋๊ณ , ์์ฃผ ์ฌ์ฉํ ๊ฒ ๊ฐ์ ์ดํฐ๋ ์ดํฐ๋ง ์์ฑํ ๊ฒ์ด๋ค.
2. ๋ฌดํ ์ดํฐ๋ ์ดํฐ
2.1 Count()
from itertools import count
a=count(10,10)
#-------ํธ์ถ----------------------
next(a)
#๊ฒฐ๊ณผ : 10
next(a)
#๊ฒฐ๊ณผ : 20
.
.
.
- count(์์์ซ์, ๋ํด์ค์ซ์) ์ ๋ ฅํด์ฃผ๋ฉด ๋ฌดํ์ผ๋ก ๊ณ์ ๊ท์น์ ๋ง๊ฒ ํธ์ถ๋๋ค.
2.2 Cycle()
from itertools import cycle
a = cycle([1,2,3,4,5])
#--------๊ฒฐ๊ณผํธ์ถ------------
next(a)
# ๊ฒฐ๊ณผ : 1
next(a)
# ๊ฒฐ๊ณผ : 2
- a ์ cycle์ ์ ๋ ฅ๋ ๋ฆฌ์คํธ๊ฐ ๋ฐ๋ณต๋์ด cycle์ ๋ค์ด๊ฐ๋ค. ๋ฐ๋ผ์ 5 ๋ค์์ next๋ 1๋ก ๋ค์ ์ฒ์์ผ๋ก ๋์๊ฐ๋ ๋ฌดํ ๋ฐ๋ณต ์ฌ์ดํด์ ์์ฑํ๋ค.
2.3 repeat()
from itertools import repeat
a = repeat("AAA", 4)
print(next(a))
print(next(a))
print(next(a))
print(next(a))
print(next(a))
- repeat(๋ฐ๋ณตํ ๊ฒ, ๋ฐ๋ณตํ์) ๋ก ์ง์
- ์์ ์์์์๋ 4๋ฒ ์ AAA๋ฅผ ์ถ๋ ฅํ ํ, ๋ค์ฏ๋ฒ์งธ๋ ์ถ๋ ฅ์ ๋ชปํ๊ณ ์ค๋ฅ๊ฐ ๋๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
3. ์กฐํฉ ์ดํฐ๋ ์ดํฐ
3.1 product()
from itertools import product
a = ["a", "b", "c"]
pd = list(product(a, repeat = 3))
- product(list, repeat = n) repeat ๋ถ๋ถ์๋ ๋ช๊ฐ ์ฉ ์กฐํฉํ ๊ฑด์ง ์ฐ๋ ๊ฑฐ๋ผ๊ณ ์ดํดํ๋ฉด ๋๋ค.
- ๋ฐ์นด๋ฅดํธ์ ๊ณฑ . ์ค์ฒฉ๋ for๋ฃจํ์ ๋์ผ
- ๋ ๊ฐ ์ด์์ ๋ฆฌ์คํธ์ ๋ชจ๋ ์กฐํฉ์ ๊ตฌํ ๋ ์ฃผ๋ก ์ฌ์ฉ๋๋ค.
- ๋ฆฌ์คํธ a ์ ์๋ ๋ชจ๋ ์์ ์กฐํฉ ๋ฐฉ๋ฒ์ด pd์ ๋ค์ด๊ฐ๋ค.
- ์ค๋ณต์ด ํ์ฉ๋๋ ๊ฒ์ ๋ณผ ์๊ฐ ์๋ค.
- len(pd) ๋ 27์ด ๋์จ๋ค (3๊ฐ๋ฅผ ์ค๋ณต์ ํ์ฉํ ์ฑ ์กฐํฉํด์ ๋์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์)
st = list(product('ABCD', repeat=2))
st
- ๋ฆฌ์คํธ์ด๋, strํํ์ด๋ ์๊ด์๋ค.
# ๋ ๊ฐ ์ด์์ ์กฐํฉ์ ๊ตฌํ ๋
from itertools import product
a = ["a", "b", "c"]
b = [1,2,3]
pd = list(product(a, b, repeat=1))
3.2 permutations()
from itertools import permutations
a = [1, 2, 3]
permut = list(permutations(a, 3))
print(permut)
- ํ ๋ฆฌ์คํธ ๋ด ์์๋ง ์ค๋ณต์ ํ์ฉํ ์ฑ๋ก ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ค.
- ์์ด์ ํํํ ๋ ์ฌ์ฉ๋๋ ๋ฉ์๋ ์ด๋ค.
3.3 combinations()
from itertools import combinations
a = [1, 2, 3]
combi = list(combinations(a, 2))
print(combi)
- ์กฐํฉ์ ๊ตฌํ๋ ๋ฉ์๋ ์ด๋ค.
- ๋ฆฌ์คํธ์์ ์ค๋ณต์ ํ์ฉํ์ง ์๊ณ ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ค.
# ๊ฐฏ์ ๋ณ๋ก ์กฐํฉ์ ๋ฐ๋ณตํ ์ ์๋ค.
a = [1, 2, 3]
for i in range(1, len(a) + 1):
print(list(combinations(a, i)))
- ๋ฐ๋ก ์์ ์ฒ๋ผ for๋ฌธ ์์ ๋ฃ๊ณ , ๊ฐฏ์๋ณ๋ก ์กฐํฉ์ ์์ฑํ ์ ์๋ค.
3.4 combinations_with_replacement()
combinations๊ณผ ๋์ผํ๋ฐ, ์๊ธฐ์์ ๊ณผ์ ์กฐํฉ๊น์ง ์ถ๋ ฅํด์ค๋ค. ์๋ ๋ ๋ฉ์๋์ ์ฐจ์ด์ ์ ๋ณด๋ฉด ์ดํด๊ฐ ๋ ๊ฒ์ด๋ค.
์ฐธ๊ณ ์๋ฃ
https://docs.python.org/ko/3.8/library/itertools.html#itertools.count
https://velog.io/@davkim1030/Python-%EC%88%9C%EC%97%B4-%EC%A1%B0%ED%95%A9-product-itertools
๋ฐ์ํ
'potato's Dev Note > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] ํ์ด์ฌ ๋ฆฌ์คํธ ๋น๊ตํ๊ธฐ (set ์๋ฃํ ์ด์ฉํ๊ธฐ!) (2) | 2021.08.18 |
---|---|
[ํ์ด์ฌ] ํด๋์ค์ ๊ฐ์ฒด / ์์ฑ์(__init__) / ํด๋์ค์ ์์, ์ค๋ฒ๋ผ์ด๋ฉ (0) | 2021.07.21 |